```
### Defaults
The file
[config/default.yml](https://github.com/bbatsov/rubocop/blob/master/config/default.yml)
under the RuboCop home directory contains the default settings that
all configurations inherit from. Project and personal `.rubocop.yml`
files need only make settings that are different from the default
ones. If there is no `.rubocop.yml` file in the project or home
directory, `config/default.yml` will be used.
### Including/Excluding files
RuboCop checks all files found by a recursive search starting from the
directory it is run in, or directories given as command line
arguments. However, it only recognizes files ending with `.rb` or
extensionless files with a `#!.*ruby` declaration as Ruby files.
Hidden directories (i.e., directories whose names start with a dot)
are not searched by default. If you'd like it to check files that are
not included by default, you'll need to pass them in on the command
line, or to add entries for them under `AllCops`/`Include`. Files and
directories can also be ignored through `AllCops`/`Exclude`.
Here is an example that might be used for a Rails project:
```yaml
AllCops:
Include:
- '**/Rakefile'
- '**/config.ru'
Exclude:
- 'db/**/*'
- 'config/**/*'
- 'script/**/*'
- !ruby/regexp /old_and_unused\.rb$/
# other configuration
# ...
```
In `.rubocop.yml` and any other configuration file beginning with `.rubocop`,
files and directories are specified relative to the directory where the
configuration file is. In configuration files that don't begin with `.rubocop`,
e.g. `our_company_defaults.yml`, paths are relative to the directory where
`rubocop` is run.
**Note**: Patterns that are just a file name, e.g. `Rakefile`, will match
that file name in any directory, but this pattern style is deprecated. The
correct way to match the file in any directory, including the current, is
`**/Rakefile`.
**Note**: The pattern `config/**` will match any file recursively under
`config`, but this pattern style is deprecated and should be replaced by
`config/**/*`.
**Note**: The `Include` and `Exclude` parameters are special. They are
valid for the directory tree starting where they are defined. They are not
shadowed by the setting of `Include` and `Exclude` in other `.rubocop.yml`
files in subdirectories. This is different from all other parameters, who
follow RuboCop's general principle that configuration for an inspected file
is taken from the nearest `.rubocop.yml`, searching upwards.
Cops can be run only on specific sets of files when that's needed (for
instance you might want to run some Rails model checks only on files whose
paths match `app/models/*.rb`). All cops support the
`Include` param.
```yaml
Rails/HasAndBelongsToMany:
Include:
- app/models/*.rb
```
Cops can also exclude only specific sets of files when that's needed (for
instance you might want to run some cop only on a specific file). All cops support the
`Exclude` param.
```yaml
Rails/HasAndBelongsToMany:
Exclude:
- app/models/problematic.rb
```
### Generic configuration parameters
In addition to `Include` and `Exclude`, the following parameters are available
for every cop.
#### Enabled
Specific cops can be disabled by setting `Enabled` to `false` for that specific cop.
```yaml
Metrics/LineLength:
Enabled: false
```
Most cops are enabled by default. Some cops, configured in
[config/disabled.yml](https://github.com/bbatsov/rubocop/blob/master/config/disabled.yml),
are disabled by default. The cop enabling process can be altered by
setting `DisabledByDefault` or `EnabledByDefault` (but not both) to `true`.
```yaml
AllCops:
DisabledByDefault: true
```
All cops are then disabled by default, and only cops appearing in user
configuration files are enabled. `Enabled: true` does not have to be
set for cops in user configuration. They will be enabled anyway.
```yaml
AllCops:
EnabledByDefault: true
```
All cops are then enabled by default, and only cops explicitly disabled
using `Enabled: false` in user configuration files are enabled.
#### Severity
Each cop has a default severity level based on which department it belongs
to. The level is `warning` for `Lint` and `convention` for all the others.
Cops can customize their severity level. Allowed params are `refactor`,
`convention`, `warning`, `error` and `fatal`.
There is one exception from the general rule above and that is `Lint/Syntax`, a
special cop that checks for syntax errors before the other cops are invoked. It
can not be disabled and its severity (`fatal`) can not be changed in
configuration.
```yaml
Metrics/CyclomaticComplexity:
Severity: warning
```
#### Details
Individual cops can be embellished with extra details in offense messages:
```yaml
Metrics/LineLength:
Details: >-
If lines are too short, text becomes hard to read because you must
constantly jump from one line to the next while reading. If lines are too
long, the line jumping becomes too hard because you "lose the line" while
going back to the start of the next line. 80 characters is a good
compromise.
```
#### AutoCorrect
Cops that support the `--auto-correct` option can have that support
disabled. For example:
```yaml
Style/PerlBackrefs:
AutoCorrect: false
```
### Setting the target Ruby version
Some checks are dependent on the version of the Ruby interpreter which the
inspected code must run on. For example, using Ruby 2.0+ keyword arguments
rather than an options hash can help make your code shorter and more
expressive... _unless_ it must run on Ruby 1.9.
If `.ruby-version` exists in the directory RuboCop is invoked in, RuboCop
will use the version specified by it. Otherwise, users may let RuboCop
know the oldest version of Ruby which your project supports with:
```yaml
AllCops:
TargetRubyVersion: 1.9
```
### Automatically Generated Configuration
If you have a code base with an overwhelming amount of offenses, it can
be a good idea to use `rubocop --auto-gen-config` and add an
`inherit_from: .rubocop_todo.yml` in your `.rubocop.yml`. The generated
file `.rubocop_todo.yml` contains configuration to disable cops that
currently detect an offense in the code by excluding the offending
files, or disabling the cop altogether once a file count limit has been
reached.
By adding the option `--exclude-limit COUNT`, e.g., `rubocop
--auto-gen-config --exclude-limit 5`, you can change how many files are
excluded before the cop is entirely disabled. The default COUNT is 15.
Then you can start removing the entries in the generated
`.rubocop_todo.yml` file one by one as you work through all the offenses
in the code.
## Disabling Cops within Source Code
One or more individual cops can be disabled locally in a section of a
file by adding a comment such as
```ruby
# rubocop:disable Metrics/LineLength, Style/StringLiterals
[...]
# rubocop:enable Metrics/LineLength, Style/StringLiterals
```
You can also disable *all* cops with
```ruby
# rubocop:disable all
[...]
# rubocop:enable all
```
One or more cops can be disabled on a single line with an end-of-line
comment.
```ruby
for x in (0..19) # rubocop:disable Style/AvoidFor
```
rubocop-0.48.1+dfsg.orig/manual/contributing.md 0000664 0000000 0000000 00000005733 13070542236 0021453 0 ustar 00root root 0000000 0000000 ## Issues
Report issues and suggest features and improvements on the
[GitHub issue tracker](https://github.com/bbatsov/rubocop/issues). Don't ask
questions on the issue tracker - use the [support channels](support.md) instead.
If you want to file a bug, please provide all the necessary info listed in
our issue reporting template (it's loaded automatically when you create a
new GitHub issue).
## Patches
Patches in any form are always welcome! GitHub pull requests are even better! :-)
Before submitting a patch or a pull request make sure all tests are
passing and that your patch is in line with the [contribution
guidelines](https://github.com/bbatsov/rubocop/blob/master/.github/CONTRIBUTING.md).
See also. [development.md](development.md)
## Documentation
Good documentation is just as important as good code.
Consider improving and extending the
this manual and the
[community wiki](https://github.com/bbatsov/rubocop/wiki).
### Working on the Manual
The manual is generated from the markdown files in the
[doc](https://github.com/bbatsov/rubocop/tree/master/manual) folder of RuboCop's
GitHub repo and is published to [Read the Docs](readthedocs.org). The
[MkDocs](http://www.mkdocs.org/) tool is used to convert the markdown sources to
HTML.
To make changes to the manual you simply have to change the files under
`manual`. The manual will be regenerated automatically when changes to those files
are merged in `master` (or the latest stable branch).
You can install `MkDocs` locally and use the command `mkdocs serve` to see the
result of changes you make to the manual locally:
```
$ cd path/to/rubocop/repo
$ mkdocs serve
```
If you want to make changes to the manual's page structure you'll have to edit
[mkdocs.yml](https://github.com/bbatsov/rubocop/blob/master/mkdocs.yml).
## Funding
While RuboCop is free software and will always be, the project would benefit immensely from some funding.
Raising a monthly budget of a couple of thousand dollars would make it possible to pay people to work on
certain complex features, fund other development related stuff (e.g. hardware, conference trips) and so on.
Raising a monthly budget of over $5000 would open the possibility of someone working full-time on the project
which would speed up the pace of development significantly.
We welcome both individual and corporate sponsors! We also offer a wide array of funding channels to account
for your preferences (although currently [Open Collective](https://opencollective.com/rubocop) is our preferred funding platform).
If you're working in a company that's making significant use of RuboCop we'd appreciate it if you suggest to your company
to become a RuboCop sponsor.
You can support the development of RuboCop via
[Salt](https://salt.bountysource.com/teams/rubocop),
[Gratipay](https://www.gratipay.com/rubocop) and [Open Collective](https://opencollective.com/rubocop).
[](https://gratipay.com/rubocop)
rubocop-0.48.1+dfsg.orig/manual/cops.md 0000664 0000000 0000000 00000057360 13070542236 0017713 0 ustar 00root root 0000000 0000000 ## Cops
In RuboCop lingo the various checks performed on the code are called cops. There are several cop departments.
You can also load [custom cops](extensions.md#custom-cops).
### Style
Most of the cops in RuboCop are so called style cops that check for
stylistic problems in your code. Almost all of the them are based on
the Ruby Style Guide. Many of the style cops have configurations
options allowing them to support different popular coding
conventions.
### Lint
Lint cops check for possible errors and very bad practices in your
code. RuboCop implements in a portable way all built-in MRI lint
checks (`ruby -wc`) and adds a lot of extra lint checks of its
own. You can run only the lint cops like this:
```sh
$ rubocop -l
```
The `-l`/`--lint` option can be used together with `--only` to run all the
enabled lint cops plus a selection of other cops.
Disabling any of the lint cops is generally a bad idea.
### Metrics
Metrics cops deal with properties of the source code that can be measured,
such as class length, method length, etc. Generally speaking, they have a
configuration parameter called `Max` and when running
`rubocop --auto-gen-config`, this parameter will be set to the highest value
found for the inspected code.
### Performance
Performance cops catch Ruby idioms which are known to be slower than another
equivalent (and equally readable) idiom.
### Rails
Rails cops are specific to the Ruby on Rails framework. Unlike all
other cop types they are not used by default and you have to request
them specifically:
```sh
$ rubocop -R
```
or add the following directive to your `.rubocop.yml`:
```yaml
Rails:
Enabled: true
```
### Bundler
Bundler cops check for style or bad practices in Bundler files, e.g. `Gemfile`.
### Available cops
In the following section you find all available cops:
#### Department [Bundler](cops_bundler.md)
* [Bundler/DuplicatedGem](cops_bundler.md#bundlerduplicatedgem)
* [Bundler/OrderedGems](cops_bundler.md#bundlerorderedgems)
#### Department [Lint](cops_lint.md)
* [Lint/AmbiguousBlockAssociation](cops_lint.md#lintambiguousblockassociation)
* [Lint/AmbiguousOperator](cops_lint.md#lintambiguousoperator)
* [Lint/AmbiguousRegexpLiteral](cops_lint.md#lintambiguousregexpliteral)
* [Lint/AssignmentInCondition](cops_lint.md#lintassignmentincondition)
* [Lint/BlockAlignment](cops_lint.md#lintblockalignment)
* [Lint/CircularArgumentReference](cops_lint.md#lintcircularargumentreference)
* [Lint/ConditionPosition](cops_lint.md#lintconditionposition)
* [Lint/Debugger](cops_lint.md#lintdebugger)
* [Lint/DefEndAlignment](cops_lint.md#lintdefendalignment)
* [Lint/DeprecatedClassMethods](cops_lint.md#lintdeprecatedclassmethods)
* [Lint/DuplicateCaseCondition](cops_lint.md#lintduplicatecasecondition)
* [Lint/DuplicateMethods](cops_lint.md#lintduplicatemethods)
* [Lint/DuplicatedKey](cops_lint.md#lintduplicatedkey)
* [Lint/EachWithObjectArgument](cops_lint.md#linteachwithobjectargument)
* [Lint/ElseLayout](cops_lint.md#lintelselayout)
* [Lint/EmptyEnsure](cops_lint.md#lintemptyensure)
* [Lint/EmptyExpression](cops_lint.md#lintemptyexpression)
* [Lint/EmptyInterpolation](cops_lint.md#lintemptyinterpolation)
* [Lint/EmptyWhen](cops_lint.md#lintemptywhen)
* [Lint/EndAlignment](cops_lint.md#lintendalignment)
* [Lint/EndInMethod](cops_lint.md#lintendinmethod)
* [Lint/EnsureReturn](cops_lint.md#lintensurereturn)
* [Lint/FloatOutOfRange](cops_lint.md#lintfloatoutofrange)
* [Lint/FormatParameterMismatch](cops_lint.md#lintformatparametermismatch)
* [Lint/HandleExceptions](cops_lint.md#linthandleexceptions)
* [Lint/ImplicitStringConcatenation](cops_lint.md#lintimplicitstringconcatenation)
* [Lint/IneffectiveAccessModifier](cops_lint.md#lintineffectiveaccessmodifier)
* [Lint/InheritException](cops_lint.md#lintinheritexception)
* [Lint/InvalidCharacterLiteral](cops_lint.md#lintinvalidcharacterliteral)
* [Lint/LiteralInCondition](cops_lint.md#lintliteralincondition)
* [Lint/LiteralInInterpolation](cops_lint.md#lintliteralininterpolation)
* [Lint/Loop](cops_lint.md#lintloop)
* [Lint/MultipleCompare](cops_lint.md#lintmultiplecompare)
* [Lint/NestedMethodDefinition](cops_lint.md#lintnestedmethoddefinition)
* [Lint/NextWithoutAccumulator](cops_lint.md#lintnextwithoutaccumulator)
* [Lint/NonLocalExitFromIterator](cops_lint.md#lintnonlocalexitfromiterator)
* [Lint/ParenthesesAsGroupedExpression](cops_lint.md#lintparenthesesasgroupedexpression)
* [Lint/PercentStringArray](cops_lint.md#lintpercentstringarray)
* [Lint/PercentSymbolArray](cops_lint.md#lintpercentsymbolarray)
* [Lint/RandOne](cops_lint.md#lintrandone)
* [Lint/RequireParentheses](cops_lint.md#lintrequireparentheses)
* [Lint/RescueException](cops_lint.md#lintrescueexception)
* [Lint/SafeNavigationChain](cops_lint.md#lintsafenavigationchain)
* [Lint/ShadowedException](cops_lint.md#lintshadowedexception)
* [Lint/ShadowingOuterLocalVariable](cops_lint.md#lintshadowingouterlocalvariable)
* [Lint/StringConversionInInterpolation](cops_lint.md#lintstringconversionininterpolation)
* [Lint/UnderscorePrefixedVariableName](cops_lint.md#lintunderscoreprefixedvariablename)
* [Lint/UnifiedInteger](cops_lint.md#lintunifiedinteger)
* [Lint/UnneededDisable](cops_lint.md#lintunneededdisable)
* [Lint/UnneededSplatExpansion](cops_lint.md#lintunneededsplatexpansion)
* [Lint/UnreachableCode](cops_lint.md#lintunreachablecode)
* [Lint/UnusedBlockArgument](cops_lint.md#lintunusedblockargument)
* [Lint/UnusedMethodArgument](cops_lint.md#lintunusedmethodargument)
* [Lint/UselessAccessModifier](cops_lint.md#lintuselessaccessmodifier)
* [Lint/UselessAssignment](cops_lint.md#lintuselessassignment)
* [Lint/UselessComparison](cops_lint.md#lintuselesscomparison)
* [Lint/UselessElseWithoutRescue](cops_lint.md#lintuselesselsewithoutrescue)
* [Lint/UselessSetterCall](cops_lint.md#lintuselesssettercall)
* [Lint/Void](cops_lint.md#lintvoid)
#### Department [Metrics](cops_metrics.md)
* [Metrics/AbcSize](cops_metrics.md#metricsabcsize)
* [Metrics/BlockLength](cops_metrics.md#metricsblocklength)
* [Metrics/BlockNesting](cops_metrics.md#metricsblocknesting)
* [Metrics/ClassLength](cops_metrics.md#metricsclasslength)
* [Metrics/CyclomaticComplexity](cops_metrics.md#metricscyclomaticcomplexity)
* [Metrics/LineLength](cops_metrics.md#metricslinelength)
* [Metrics/MethodLength](cops_metrics.md#metricsmethodlength)
* [Metrics/ModuleLength](cops_metrics.md#metricsmodulelength)
* [Metrics/ParameterLists](cops_metrics.md#metricsparameterlists)
* [Metrics/PerceivedComplexity](cops_metrics.md#metricsperceivedcomplexity)
#### Department [Performance](cops_performance.md)
* [Performance/CaseWhenSplat](cops_performance.md#performancecasewhensplat)
* [Performance/Casecmp](cops_performance.md#performancecasecmp)
* [Performance/CompareWithBlock](cops_performance.md#performancecomparewithblock)
* [Performance/Count](cops_performance.md#performancecount)
* [Performance/Detect](cops_performance.md#performancedetect)
* [Performance/DoubleStartEndWith](cops_performance.md#performancedoublestartendwith)
* [Performance/EndWith](cops_performance.md#performanceendwith)
* [Performance/FixedSize](cops_performance.md#performancefixedsize)
* [Performance/FlatMap](cops_performance.md#performanceflatmap)
* [Performance/HashEachMethods](cops_performance.md#performancehasheachmethods)
* [Performance/LstripRstrip](cops_performance.md#performancelstriprstrip)
* [Performance/RangeInclude](cops_performance.md#performancerangeinclude)
* [Performance/RedundantBlockCall](cops_performance.md#performanceredundantblockcall)
* [Performance/RedundantMatch](cops_performance.md#performanceredundantmatch)
* [Performance/RedundantMerge](cops_performance.md#performanceredundantmerge)
* [Performance/RedundantSortBy](cops_performance.md#performanceredundantsortby)
* [Performance/RegexpMatch](cops_performance.md#performanceregexpmatch)
* [Performance/ReverseEach](cops_performance.md#performancereverseeach)
* [Performance/Sample](cops_performance.md#performancesample)
* [Performance/Size](cops_performance.md#performancesize)
* [Performance/StartWith](cops_performance.md#performancestartwith)
* [Performance/StringReplacement](cops_performance.md#performancestringreplacement)
* [Performance/TimesMap](cops_performance.md#performancetimesmap)
#### Department [Rails](cops_rails.md)
* [Rails/ActionFilter](cops_rails.md#railsactionfilter)
* [Rails/ActiveSupportAliases](cops_rails.md#railsactivesupportaliases)
* [Rails/Blank](cops_rails.md#railsblank)
* [Rails/Date](cops_rails.md#railsdate)
* [Rails/Delegate](cops_rails.md#railsdelegate)
* [Rails/DelegateAllowBlank](cops_rails.md#railsdelegateallowblank)
* [Rails/DynamicFindBy](cops_rails.md#railsdynamicfindby)
* [Rails/EnumUniqueness](cops_rails.md#railsenumuniqueness)
* [Rails/Exit](cops_rails.md#railsexit)
* [Rails/FilePath](cops_rails.md#railsfilepath)
* [Rails/FindBy](cops_rails.md#railsfindby)
* [Rails/FindEach](cops_rails.md#railsfindeach)
* [Rails/HasAndBelongsToMany](cops_rails.md#railshasandbelongstomany)
* [Rails/HttpPositionalArguments](cops_rails.md#railshttppositionalarguments)
* [Rails/NotNullColumn](cops_rails.md#railsnotnullcolumn)
* [Rails/Output](cops_rails.md#railsoutput)
* [Rails/OutputSafety](cops_rails.md#railsoutputsafety)
* [Rails/PluralizationGrammar](cops_rails.md#railspluralizationgrammar)
* [Rails/Present](cops_rails.md#railspresent)
* [Rails/ReadWriteAttribute](cops_rails.md#railsreadwriteattribute)
* [Rails/RelativeDateConstant](cops_rails.md#railsrelativedateconstant)
* [Rails/RequestReferer](cops_rails.md#railsrequestreferer)
* [Rails/ReversibleMigration](cops_rails.md#railsreversiblemigration)
* [Rails/SafeNavigation](cops_rails.md#railssafenavigation)
* [Rails/SaveBang](cops_rails.md#railssavebang)
* [Rails/ScopeArgs](cops_rails.md#railsscopeargs)
* [Rails/SkipsModelValidations](cops_rails.md#railsskipsmodelvalidations)
* [Rails/TimeZone](cops_rails.md#railstimezone)
* [Rails/UniqBeforePluck](cops_rails.md#railsuniqbeforepluck)
* [Rails/Validation](cops_rails.md#railsvalidation)
#### Department [Security](cops_security.md)
* [Security/Eval](cops_security.md#securityeval)
* [Security/JSONLoad](cops_security.md#securityjsonload)
* [Security/MarshalLoad](cops_security.md#securitymarshalload)
* [Security/YAMLLoad](cops_security.md#securityyamlload)
#### Department [Style](cops_style.md)
* [Style/AccessModifierIndentation](cops_style.md#styleaccessmodifierindentation)
* [Style/AccessorMethodName](cops_style.md#styleaccessormethodname)
* [Style/Alias](cops_style.md#stylealias)
* [Style/AlignArray](cops_style.md#stylealignarray)
* [Style/AlignHash](cops_style.md#stylealignhash)
* [Style/AlignParameters](cops_style.md#stylealignparameters)
* [Style/AndOr](cops_style.md#styleandor)
* [Style/ArrayJoin](cops_style.md#stylearrayjoin)
* [Style/AsciiComments](cops_style.md#styleasciicomments)
* [Style/AsciiIdentifiers](cops_style.md#styleasciiidentifiers)
* [Style/Attr](cops_style.md#styleattr)
* [Style/AutoResourceCleanup](cops_style.md#styleautoresourcecleanup)
* [Style/BarePercentLiterals](cops_style.md#stylebarepercentliterals)
* [Style/BeginBlock](cops_style.md#stylebeginblock)
* [Style/BlockComments](cops_style.md#styleblockcomments)
* [Style/BlockDelimiters](cops_style.md#styleblockdelimiters)
* [Style/BlockEndNewline](cops_style.md#styleblockendnewline)
* [Style/BracesAroundHashParameters](cops_style.md#stylebracesaroundhashparameters)
* [Style/CaseEquality](cops_style.md#stylecaseequality)
* [Style/CaseIndentation](cops_style.md#stylecaseindentation)
* [Style/CharacterLiteral](cops_style.md#stylecharacterliteral)
* [Style/ClassAndModuleCamelCase](cops_style.md#styleclassandmodulecamelcase)
* [Style/ClassAndModuleChildren](cops_style.md#styleclassandmodulechildren)
* [Style/ClassCheck](cops_style.md#styleclasscheck)
* [Style/ClassMethods](cops_style.md#styleclassmethods)
* [Style/ClassVars](cops_style.md#styleclassvars)
* [Style/ClosingParenthesisIndentation](cops_style.md#styleclosingparenthesisindentation)
* [Style/CollectionMethods](cops_style.md#stylecollectionmethods)
* [Style/ColonMethodCall](cops_style.md#stylecolonmethodcall)
* [Style/CommandLiteral](cops_style.md#stylecommandliteral)
* [Style/CommentAnnotation](cops_style.md#stylecommentannotation)
* [Style/CommentIndentation](cops_style.md#stylecommentindentation)
* [Style/ConditionalAssignment](cops_style.md#styleconditionalassignment)
* [Style/ConstantName](cops_style.md#styleconstantname)
* [Style/Copyright](cops_style.md#stylecopyright)
* [Style/DefWithParentheses](cops_style.md#styledefwithparentheses)
* [Style/Documentation](cops_style.md#styledocumentation)
* [Style/DocumentationMethod](cops_style.md#styledocumentationmethod)
* [Style/DotPosition](cops_style.md#styledotposition)
* [Style/DoubleNegation](cops_style.md#styledoublenegation)
* [Style/EachForSimpleLoop](cops_style.md#styleeachforsimpleloop)
* [Style/EachWithObject](cops_style.md#styleeachwithobject)
* [Style/ElseAlignment](cops_style.md#styleelsealignment)
* [Style/EmptyCaseCondition](cops_style.md#styleemptycasecondition)
* [Style/EmptyElse](cops_style.md#styleemptyelse)
* [Style/EmptyLineAfterMagicComment](cops_style.md#styleemptylineaftermagiccomment)
* [Style/EmptyLineBetweenDefs](cops_style.md#styleemptylinebetweendefs)
* [Style/EmptyLines](cops_style.md#styleemptylines)
* [Style/EmptyLinesAroundAccessModifier](cops_style.md#styleemptylinesaroundaccessmodifier)
* [Style/EmptyLinesAroundBeginBody](cops_style.md#styleemptylinesaroundbeginbody)
* [Style/EmptyLinesAroundBlockBody](cops_style.md#styleemptylinesaroundblockbody)
* [Style/EmptyLinesAroundClassBody](cops_style.md#styleemptylinesaroundclassbody)
* [Style/EmptyLinesAroundExceptionHandlingKeywords](cops_style.md#styleemptylinesaroundexceptionhandlingkeywords)
* [Style/EmptyLinesAroundMethodBody](cops_style.md#styleemptylinesaroundmethodbody)
* [Style/EmptyLinesAroundModuleBody](cops_style.md#styleemptylinesaroundmodulebody)
* [Style/EmptyLiteral](cops_style.md#styleemptyliteral)
* [Style/EmptyMethod](cops_style.md#styleemptymethod)
* [Style/Encoding](cops_style.md#styleencoding)
* [Style/EndBlock](cops_style.md#styleendblock)
* [Style/EndOfLine](cops_style.md#styleendofline)
* [Style/EvenOdd](cops_style.md#styleevenodd)
* [Style/ExtraSpacing](cops_style.md#styleextraspacing)
* [Style/FileName](cops_style.md#stylefilename)
* [Style/FirstArrayElementLineBreak](cops_style.md#stylefirstarrayelementlinebreak)
* [Style/FirstHashElementLineBreak](cops_style.md#stylefirsthashelementlinebreak)
* [Style/FirstMethodArgumentLineBreak](cops_style.md#stylefirstmethodargumentlinebreak)
* [Style/FirstMethodParameterLineBreak](cops_style.md#stylefirstmethodparameterlinebreak)
* [Style/FirstParameterIndentation](cops_style.md#stylefirstparameterindentation)
* [Style/FlipFlop](cops_style.md#styleflipflop)
* [Style/For](cops_style.md#stylefor)
* [Style/FormatString](cops_style.md#styleformatstring)
* [Style/FrozenStringLiteralComment](cops_style.md#stylefrozenstringliteralcomment)
* [Style/GlobalVars](cops_style.md#styleglobalvars)
* [Style/GuardClause](cops_style.md#styleguardclause)
* [Style/HashSyntax](cops_style.md#stylehashsyntax)
* [Style/IdenticalConditionalBranches](cops_style.md#styleidenticalconditionalbranches)
* [Style/IfInsideElse](cops_style.md#styleifinsideelse)
* [Style/IfUnlessModifier](cops_style.md#styleifunlessmodifier)
* [Style/IfUnlessModifierOfIfUnless](cops_style.md#styleifunlessmodifierofifunless)
* [Style/IfWithSemicolon](cops_style.md#styleifwithsemicolon)
* [Style/ImplicitRuntimeError](cops_style.md#styleimplicitruntimeerror)
* [Style/IndentArray](cops_style.md#styleindentarray)
* [Style/IndentAssignment](cops_style.md#styleindentassignment)
* [Style/IndentHash](cops_style.md#styleindenthash)
* [Style/IndentHeredoc](cops_style.md#styleindentheredoc)
* [Style/IndentationConsistency](cops_style.md#styleindentationconsistency)
* [Style/IndentationWidth](cops_style.md#styleindentationwidth)
* [Style/InfiniteLoop](cops_style.md#styleinfiniteloop)
* [Style/InitialIndentation](cops_style.md#styleinitialindentation)
* [Style/InlineComment](cops_style.md#styleinlinecomment)
* [Style/InverseMethods](cops_style.md#styleinversemethods)
* [Style/Lambda](cops_style.md#stylelambda)
* [Style/LambdaCall](cops_style.md#stylelambdacall)
* [Style/LeadingCommentSpace](cops_style.md#styleleadingcommentspace)
* [Style/LineEndConcatenation](cops_style.md#stylelineendconcatenation)
* [Style/MethodCallWithArgsParentheses](cops_style.md#stylemethodcallwithargsparentheses)
* [Style/MethodCallWithoutArgsParentheses](cops_style.md#stylemethodcallwithoutargsparentheses)
* [Style/MethodCalledOnDoEndBlock](cops_style.md#stylemethodcalledondoendblock)
* [Style/MethodDefParentheses](cops_style.md#stylemethoddefparentheses)
* [Style/MethodMissing](cops_style.md#stylemethodmissing)
* [Style/MethodName](cops_style.md#stylemethodname)
* [Style/MissingElse](cops_style.md#stylemissingelse)
* [Style/MixinGrouping](cops_style.md#stylemixingrouping)
* [Style/ModuleFunction](cops_style.md#stylemodulefunction)
* [Style/MultilineArrayBraceLayout](cops_style.md#stylemultilinearraybracelayout)
* [Style/MultilineAssignmentLayout](cops_style.md#stylemultilineassignmentlayout)
* [Style/MultilineBlockChain](cops_style.md#stylemultilineblockchain)
* [Style/MultilineBlockLayout](cops_style.md#stylemultilineblocklayout)
* [Style/MultilineHashBraceLayout](cops_style.md#stylemultilinehashbracelayout)
* [Style/MultilineIfModifier](cops_style.md#stylemultilineifmodifier)
* [Style/MultilineIfThen](cops_style.md#stylemultilineifthen)
* [Style/MultilineMemoization](cops_style.md#stylemultilinememoization)
* [Style/MultilineMethodCallBraceLayout](cops_style.md#stylemultilinemethodcallbracelayout)
* [Style/MultilineMethodCallIndentation](cops_style.md#stylemultilinemethodcallindentation)
* [Style/MultilineMethodDefinitionBraceLayout](cops_style.md#stylemultilinemethoddefinitionbracelayout)
* [Style/MultilineOperationIndentation](cops_style.md#stylemultilineoperationindentation)
* [Style/MultilineTernaryOperator](cops_style.md#stylemultilineternaryoperator)
* [Style/MutableConstant](cops_style.md#stylemutableconstant)
* [Style/NegatedIf](cops_style.md#stylenegatedif)
* [Style/NegatedWhile](cops_style.md#stylenegatedwhile)
* [Style/NestedModifier](cops_style.md#stylenestedmodifier)
* [Style/NestedParenthesizedCalls](cops_style.md#stylenestedparenthesizedcalls)
* [Style/NestedTernaryOperator](cops_style.md#stylenestedternaryoperator)
* [Style/Next](cops_style.md#stylenext)
* [Style/NilComparison](cops_style.md#stylenilcomparison)
* [Style/NonNilCheck](cops_style.md#stylenonnilcheck)
* [Style/Not](cops_style.md#stylenot)
* [Style/NumericLiteralPrefix](cops_style.md#stylenumericliteralprefix)
* [Style/NumericLiterals](cops_style.md#stylenumericliterals)
* [Style/NumericPredicate](cops_style.md#stylenumericpredicate)
* [Style/OneLineConditional](cops_style.md#styleonelineconditional)
* [Style/OpMethod](cops_style.md#styleopmethod)
* [Style/OptionHash](cops_style.md#styleoptionhash)
* [Style/OptionalArguments](cops_style.md#styleoptionalarguments)
* [Style/ParallelAssignment](cops_style.md#styleparallelassignment)
* [Style/ParenthesesAroundCondition](cops_style.md#styleparenthesesaroundcondition)
* [Style/PercentLiteralDelimiters](cops_style.md#stylepercentliteraldelimiters)
* [Style/PercentQLiterals](cops_style.md#stylepercentqliterals)
* [Style/PerlBackrefs](cops_style.md#styleperlbackrefs)
* [Style/PredicateName](cops_style.md#stylepredicatename)
* [Style/PreferredHashMethods](cops_style.md#stylepreferredhashmethods)
* [Style/Proc](cops_style.md#styleproc)
* [Style/RaiseArgs](cops_style.md#styleraiseargs)
* [Style/RedundantBegin](cops_style.md#styleredundantbegin)
* [Style/RedundantException](cops_style.md#styleredundantexception)
* [Style/RedundantFreeze](cops_style.md#styleredundantfreeze)
* [Style/RedundantParentheses](cops_style.md#styleredundantparentheses)
* [Style/RedundantReturn](cops_style.md#styleredundantreturn)
* [Style/RedundantSelf](cops_style.md#styleredundantself)
* [Style/RegexpLiteral](cops_style.md#styleregexpliteral)
* [Style/RescueEnsureAlignment](cops_style.md#stylerescueensurealignment)
* [Style/RescueModifier](cops_style.md#stylerescuemodifier)
* [Style/SafeNavigation](cops_style.md#stylesafenavigation)
* [Style/SelfAssignment](cops_style.md#styleselfassignment)
* [Style/Semicolon](cops_style.md#stylesemicolon)
* [Style/Send](cops_style.md#stylesend)
* [Style/SignalException](cops_style.md#stylesignalexception)
* [Style/SingleLineBlockParams](cops_style.md#stylesinglelineblockparams)
* [Style/SingleLineMethods](cops_style.md#stylesinglelinemethods)
* [Style/SpaceAfterColon](cops_style.md#stylespaceaftercolon)
* [Style/SpaceAfterComma](cops_style.md#stylespaceaftercomma)
* [Style/SpaceAfterMethodName](cops_style.md#stylespaceaftermethodname)
* [Style/SpaceAfterNot](cops_style.md#stylespaceafternot)
* [Style/SpaceAfterSemicolon](cops_style.md#stylespaceaftersemicolon)
* [Style/SpaceAroundBlockParameters](cops_style.md#stylespacearoundblockparameters)
* [Style/SpaceAroundEqualsInParameterDefault](cops_style.md#stylespacearoundequalsinparameterdefault)
* [Style/SpaceAroundKeyword](cops_style.md#stylespacearoundkeyword)
* [Style/SpaceAroundOperators](cops_style.md#stylespacearoundoperators)
* [Style/SpaceBeforeBlockBraces](cops_style.md#stylespacebeforeblockbraces)
* [Style/SpaceBeforeComma](cops_style.md#stylespacebeforecomma)
* [Style/SpaceBeforeComment](cops_style.md#stylespacebeforecomment)
* [Style/SpaceBeforeFirstArg](cops_style.md#stylespacebeforefirstarg)
* [Style/SpaceBeforeSemicolon](cops_style.md#stylespacebeforesemicolon)
* [Style/SpaceInLambdaLiteral](cops_style.md#stylespaceinlambdaliteral)
* [Style/SpaceInsideArrayPercentLiteral](cops_style.md#stylespaceinsidearraypercentliteral)
* [Style/SpaceInsideBlockBraces](cops_style.md#stylespaceinsideblockbraces)
* [Style/SpaceInsideBrackets](cops_style.md#stylespaceinsidebrackets)
* [Style/SpaceInsideHashLiteralBraces](cops_style.md#stylespaceinsidehashliteralbraces)
* [Style/SpaceInsideParens](cops_style.md#stylespaceinsideparens)
* [Style/SpaceInsidePercentLiteralDelimiters](cops_style.md#stylespaceinsidepercentliteraldelimiters)
* [Style/SpaceInsideRangeLiteral](cops_style.md#stylespaceinsiderangeliteral)
* [Style/SpaceInsideStringInterpolation](cops_style.md#stylespaceinsidestringinterpolation)
* [Style/SpecialGlobalVars](cops_style.md#stylespecialglobalvars)
* [Style/StabbyLambdaParentheses](cops_style.md#stylestabbylambdaparentheses)
* [Style/StringLiterals](cops_style.md#stylestringliterals)
* [Style/StringLiteralsInInterpolation](cops_style.md#stylestringliteralsininterpolation)
* [Style/StringMethods](cops_style.md#stylestringmethods)
* [Style/StructInheritance](cops_style.md#stylestructinheritance)
* [Style/SymbolArray](cops_style.md#stylesymbolarray)
* [Style/SymbolLiteral](cops_style.md#stylesymbolliteral)
* [Style/SymbolProc](cops_style.md#stylesymbolproc)
* [Style/Tab](cops_style.md#styletab)
* [Style/TernaryParentheses](cops_style.md#styleternaryparentheses)
* [Style/TrailingBlankLines](cops_style.md#styletrailingblanklines)
* [Style/TrailingCommaInArguments](cops_style.md#styletrailingcommainarguments)
* [Style/TrailingCommaInLiteral](cops_style.md#styletrailingcommainliteral)
* [Style/TrailingUnderscoreVariable](cops_style.md#styletrailingunderscorevariable)
* [Style/TrailingWhitespace](cops_style.md#styletrailingwhitespace)
* [Style/TrivialAccessors](cops_style.md#styletrivialaccessors)
* [Style/UnlessElse](cops_style.md#styleunlesselse)
* [Style/UnneededCapitalW](cops_style.md#styleunneededcapitalw)
* [Style/UnneededInterpolation](cops_style.md#styleunneededinterpolation)
* [Style/UnneededPercentQ](cops_style.md#styleunneededpercentq)
* [Style/VariableInterpolation](cops_style.md#stylevariableinterpolation)
* [Style/VariableName](cops_style.md#stylevariablename)
* [Style/VariableNumber](cops_style.md#stylevariablenumber)
* [Style/WhenThen](cops_style.md#stylewhenthen)
* [Style/WhileUntilDo](cops_style.md#stylewhileuntildo)
* [Style/WhileUntilModifier](cops_style.md#stylewhileuntilmodifier)
* [Style/WordArray](cops_style.md#stylewordarray)
* [Style/ZeroLengthPredicate](cops_style.md#stylezerolengthpredicate)
rubocop-0.48.1+dfsg.orig/manual/cops_bundler.md 0000664 0000000 0000000 00000002007 13070542236 0021412 0 ustar 00root root 0000000 0000000 # Bundler
## Bundler/DuplicatedGem
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
A Gem's requirements should be listed only once in a Gemfile.
### Example
```ruby
# bad
gem 'rubocop'
gem 'rubocop'
# bad
group :development do
gem 'rubocop'
end
group :test do
gem 'rubocop'
end
# good
group :development, :test do
gem 'rubocop'
end
# good
gem 'rubocop', groups: [:development, :test]
```
### Important attributes
Attribute | Value
--- | ---
Include | \*\*/Gemfile, \*\*/gems.rb
## Bundler/OrderedGems
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Gems should be alphabetically sorted within groups.
### Example
```ruby
# bad
gem 'rubocop'
gem 'rspec'
# good
gem 'rspec'
gem 'rubocop'
# good
gem 'rubocop'
gem 'rspec'
# good only if TreatCommentsAsGroupSeparators is true
# For code quality
gem 'rubocop'
# For tests
gem 'rspec'
```
### Important attributes
Attribute | Value
--- | ---
Include | \*\*/Gemfile, \*\*/gems.rb
TreatCommentsAsGroupSeparators | true
rubocop-0.48.1+dfsg.orig/manual/cops_lint.md 0000664 0000000 0000000 00000075425 13070542236 0020743 0 ustar 00root root 0000000 0000000 # Lint
## Lint/AmbiguousBlockAssociation
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for ambiguous block association with method
when param passed without parentheses.
### Example
```ruby
# bad
some_method a { |val| puts val }
```
```ruby
# good
# With parentheses, there's no ambiguity.
some_method(a) { |val| puts val }
# good
# Operator methods require no disambiguation
foo == bar { |b| b.baz }
# good
# Lambda arguments require no disambiguation
foo = ->(bar) { bar.baz }
```
### References
* [https://github.com/bbatsov/ruby-style-guide#syntax](https://github.com/bbatsov/ruby-style-guide#syntax)
## Lint/AmbiguousOperator
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for ambiguous operators in the first argument of a
method invocation without parentheses.
### Example
```ruby
# bad
# The `*` is interpreted as a splat operator but it could possibly be
# a `*` method invocation (i.e. `do_something.*(some_array)`).
do_something *some_array
```
```ruby
# good
# With parentheses, there's no ambiguity.
do_something(*some_array)
```
### References
* [https://github.com/bbatsov/ruby-style-guide#method-invocation-parens](https://github.com/bbatsov/ruby-style-guide#method-invocation-parens)
## Lint/AmbiguousRegexpLiteral
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for ambiguous regexp literals in the first argument of
a method invocation without parentheses.
### Example
```ruby
# bad
# This is interpreted as a method invocation with a regexp literal,
# but it could possibly be `/` method invocations.
# (i.e. `do_something./(pattern)./(i)`)
do_something /pattern/i
```
```ruby
# good
# With parentheses, there's no ambiguity.
do_something(/pattern/i)
```
## Lint/AssignmentInCondition
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for assignments in the conditions of
if/while/until.
### Example
```ruby
# bad
if some_var = true
do_something
end
```
```ruby
# good
if some_var == true
do_something
end
```
### Important attributes
Attribute | Value
--- | ---
AllowSafeAssignment | true
### References
* [https://github.com/bbatsov/ruby-style-guide#safe-assignment-in-condition](https://github.com/bbatsov/ruby-style-guide#safe-assignment-in-condition)
## Lint/BlockAlignment
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks whether the end keywords are aligned properly for do
end blocks.
Three modes are supported through the `EnforcedStyleAlignWith`
configuration parameter:
`start_of_block` : the `end` shall be aligned with the
start of the line where the `do` appeared.
`start_of_line` : the `end` shall be aligned with the
start of the line where the expression started.
`either` (which is the default) : the `end` is allowed to be in either
location. The autofixer will default to `start_of_line`.
### Example
```ruby
# bad
foo.bar
.each do
baz
end
```
```ruby
# EnforcedStyleAlignWith: either (default)
# good
variable = lambda do |i|
i
end
```
```ruby
# EnforcedStyleAlignWith: start_of_block
# good
foo.bar
.each do
baz
end
```
```ruby
# EnforcedStyleAlignWith: start_of_line
# good
foo.bar
.each do
baz
end
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyleAlignWith | either
SupportedStylesAlignWith | either, start_of_block, start_of_line
## Lint/CircularArgumentReference
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for circular argument references in optional keyword
arguments and optional ordinal arguments.
This cop mirrors a warning produced by MRI since 2.2.
### Example
```ruby
# bad
def bake(pie: pie)
pie.heat_up
end
```
```ruby
# good
def bake(pie:)
pie.refrigerate
end
```
```ruby
# good
def bake(pie: self.pie)
pie.feed_to(user)
end
```
```ruby
# bad
def cook(dry_ingredients = dry_ingredients)
dry_ingredients.reduce(&:+)
end
```
```ruby
# good
def cook(dry_ingredients = self.dry_ingredients)
dry_ingredients.combine
end
```
## Lint/ConditionPosition
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for conditions that are not on the same line as
if/while/until.
### Example
```ruby
# bad
if
some_condition
do_something
end
```
```ruby
# good
if some_condition
do_something
end
```
### References
* [https://github.com/bbatsov/ruby-style-guide#same-line-condition](https://github.com/bbatsov/ruby-style-guide#same-line-condition)
## Lint/Debugger
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for calls to debugger or pry.
### Example
```ruby
# bad (ok during development)
# using pry
def some_method
binding.pry
do_something
end
```
```ruby
# bad (ok during development)
# using byebug
def some_method
byebug
do_something
end
```
```ruby
# good
def some_method
do_something
end
```
## Lint/DefEndAlignment
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks whether the end keywords of method definitions are
aligned properly.
Two modes are supported through the EnforcedStyleAlignWith configuration
parameter. If it's set to `start_of_line` (which is the default), the
`end` shall be aligned with the start of the line where the `def`
keyword is. If it's set to `def`, the `end` shall be aligned with the
`def` keyword.
### Example
```ruby
# bad
private def foo
end
```
```ruby
# EnforcedStyleAlignWith: start_of_line (default)
# good
private def foo
end
```
```ruby
# EnforcedStyleAlignWith: def
# good
private def foo
end
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyleAlignWith | start_of_line
SupportedStylesAlignWith | start_of_line, def
AutoCorrect | false
## Lint/DeprecatedClassMethods
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for uses of the deprecated class method usages.
### Example
```ruby
# bad
File.exists?(some_path)
```
```ruby
# good
File.exist?(some_path)
```
## Lint/DuplicateCaseCondition
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks that there are no repeated conditions
used in case 'when' expressions.
### Example
```ruby
# bad
case x
when 'first'
do_something
when 'first'
do_something_else
end
```
```ruby
# good
case x
when 'first'
do_something
when 'second'
do_something_else
end
```
## Lint/DuplicateMethods
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for duplicated instance (or singleton) method
definitions.
### Example
```ruby
# bad
def duplicated
1
end
def duplicated
2
end
```
```ruby
# good
def duplicated
1
end
def other_duplicated
2
end
```
## Lint/DuplicatedKey
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for duplicated keys in hash literals.
This cop mirrors a warning in Ruby 2.2.
### Example
```ruby
# bad
hash = { food: 'apple', food: 'orange' }
```
```ruby
# good
hash = { food: 'apple', other_food: 'orange' }
```
## Lint/EachWithObjectArgument
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks if each_with_object is called with an immutable
argument. Since the argument is the object that the given block shall
make calls on to build something based on the enumerable that
each_with_object iterates over, an immutable argument makes no sense.
It's definitely a bug.
### Example
```ruby
# bad
sum = numbers.each_with_object(0) { |e, a| a += e }
```
```ruby
# good
num = 0
sum = numbers.each_with_object(num) { |e, a| a += e }
```
## Lint/ElseLayout
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for odd else block layout - like
having an expression on the same line as the else keyword,
which is usually a mistake.
### Example
```ruby
# bad
if something
...
else do_this
do_that
end
```
```ruby
# good
if something
...
else
do_this
do_that
end
```
## Lint/EmptyEnsure
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for empty `ensure` blocks
### Example
```ruby
# bad
def some_method
do_something
ensure
end
```
```ruby
# bad
begin
do_something
ensure
end
```
```ruby
# good
def some_method
do_something
ensure
do_something_else
end
```
```ruby
# good
begin
do_something
ensure
do_something_else
end
```
### Important attributes
Attribute | Value
--- | ---
AutoCorrect | false
## Lint/EmptyExpression
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for the presence of empty expressions.
### Example
```ruby
# bad
foo = ()
if ()
bar
end
```
```ruby
# good
foo = (some_expression)
if (some_expression)
bar
end
```
## Lint/EmptyInterpolation
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for empty interpolation.
### Example
```ruby
# bad
"result is #{}"
```
```ruby
# good
"result is #{some_result}"
```
## Lint/EmptyWhen
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for the presence of `when` branches without a body.
### Example
```ruby
# bad
case foo
when bar then 1
when baz then # nothing
end
```
```ruby
# good
case foo
when bar then 1
when baz then 2
end
```
## Lint/EndAlignment
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks whether the end keywords are aligned properly.
Three modes are supported through the `EnforcedStyleAlignWith`
configuration parameter:
If it's set to `keyword` (which is the default), the `end`
shall be aligned with the start of the keyword (if, class, etc.).
If it's set to `variable` the `end` shall be aligned with the
left-hand-side of the variable assignment, if there is one.
If it's set to `start_of_line`, the `end` shall be aligned with the
start of the line where the matching keyword appears.
### Example
```ruby
# bad
variable = if true
end
```
```ruby
# EnforcedStyleAlignWith: keyword (default)
# good
variable = if true
end
```
```ruby
# EnforcedStyleAlignWith: variable
# good
variable = if true
end
```
```ruby
# EnforcedStyleAlignWith: start_of_line
# good
puts(if true
end)
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyleAlignWith | keyword
SupportedStylesAlignWith | keyword, variable, start_of_line
AutoCorrect | false
## Lint/EndInMethod
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for END blocks in method definitions.
### Example
```ruby
# bad
def some_method
END { do_something }
end
```
```ruby
# good
def some_method
at_exit { do_something }
end
```
```ruby
# good
# outside defs
END { do_something }
```
## Lint/EnsureReturn
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for *return* from an *ensure* block.
### Example
```ruby
# bad
begin
do_something
ensure
do_something_else
return
end
```
```ruby
# good
begin
do_something
ensure
do_something_else
end
```
### References
* [https://github.com/bbatsov/ruby-style-guide#no-return-ensure](https://github.com/bbatsov/ruby-style-guide#no-return-ensure)
## Lint/FloatOutOfRange
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop identifies Float literals which are, like, really really really
really really really really really big. Too big. No-one needs Floats
that big. If you need a float that big, something is wrong with you.
### Example
```ruby
# bad
float = 3.0e400
```
```ruby
# good
float = 42.9
```
## Lint/FormatParameterMismatch
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This lint sees if there is a mismatch between the number of
expected fields for format/sprintf/#% and what is actually
passed as arguments.
### Example
```ruby
# bad
format('A value: %s and another: %i', a_value)
```
```ruby
# good
format('A value: %s and another: %i', a_value, another)
```
## Lint/HandleExceptions
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for *rescue* blocks with no body.
### Example
```ruby
# bad
def some_method
do_something
rescue
# do nothing
end
```
```ruby
# bad
begin
do_something
rescue
# do nothing
end
```
```ruby
# good
def some_method
do_something
rescue
handle_exception
end
```
```ruby
# good
begin
do_something
rescue
handle_exception
end
```
### References
* [https://github.com/bbatsov/ruby-style-guide#dont-hide-exceptions](https://github.com/bbatsov/ruby-style-guide#dont-hide-exceptions)
## Lint/ImplicitStringConcatenation
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for implicit string concatenation of string literals
which are on the same line.
### Example
```ruby
# bad
array = ['Item 1' 'Item 2']
```
```ruby
# good
array = ['Item 1Item 2']
array = ['Item 1' + 'Item 2']
array = [
'Item 1' \
'Item 2'
]
```
## Lint/IneffectiveAccessModifier
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for `private` or `protected` access modifiers which are
applied to a singleton method. These access modifiers do not make
singleton methods private/protected. `private_class_method` can be
used for that.
### Example
```ruby
# bad
class C
private
def self.method
puts 'hi'
end
end
```
```ruby
# good
class C
def self.method
puts 'hi'
end
private_class_method :method
end
```
```ruby
# good
class C
class << self
private
def method
puts 'hi'
end
end
end
```
## Lint/InheritException
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop looks for error classes inheriting from `Exception`
and its standard library subclasses, excluding subclasses of
`StandardError`. It is configurable to suggest using either
`RuntimeError` (default) or `StandardError` instead.
### Example
```ruby
# bad
class C < Exception; end
```
```ruby
# EnforcedStyle: runtime_error (default)
# good
class C < RuntimeError; end
```
```ruby
# EnforcedStyle: standard_error
# good
class C < StandardError; end
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | runtime_error
SupportedStyles | runtime_error, standard_error
## Lint/InvalidCharacterLiteral
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for invalid character literals with a non-escaped
whitespace character (e.g. `? `).
However, currently it's unclear whether there's a way to emit this
warning without syntax errors.
$ ruby -w
p(? )
-:1: warning: invalid character syntax; use ?\s
-:1: syntax error, unexpected '?', expecting ')'
p(? )
^
### Example
```ruby
# bad
p(? )
```
## Lint/LiteralInCondition
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for literals used as the conditions or as
operands in and/or expressions serving as the conditions of
if/while/until.
### Example
```ruby
# bad
if 20
do_something
end
```
```ruby
# bad
if some_var && true
do_something
end
```
```ruby
# good
if some_var && some_condition
do_something
end
```
## Lint/LiteralInInterpolation
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for interpolated literals.
### Example
```ruby
# bad
"result is #{10}"
```
```ruby
# good
"result is 10"
```
## Lint/Loop
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for uses of *begin...end while/until something*.
### Example
```ruby
# bad
# using while
begin
do_something
end while some_condition
```
```ruby
# bad
# using until
begin
do_something
end until some_condition
```
```ruby
# good
# using while
while some_condition
do_something
end
```
```ruby
# good
# using until
until some_condition
do_something
end
```
### References
* [https://github.com/bbatsov/ruby-style-guide#loop-with-break](https://github.com/bbatsov/ruby-style-guide#loop-with-break)
## Lint/MultipleCompare
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
In math and Python, we can use `x < y < z` style comparison to compare
multiple value. However, we can't use the comparison in Ruby. However,
the comparison is not syntax error. This cop checks the bad usage of
comparison operators.
### Example
```ruby
# bad
x < y < z
10 <= x <= 20
```
```ruby
# good
x < y && y < z
10 <= x && x <= 20
```
## Lint/NestedMethodDefinition
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for nested method definitions.
### Example
```ruby
# bad
# `bar` definition actually produces methods in the same scope
# as the outer `foo` method. Furthermore, the `bar` method
# will be redefined every time `foo` is invoked.
def foo
def bar
end
end
```
```ruby
# good
def foo
bar = -> { puts 'hello' }
bar.call
end
```
```ruby
# good
def foo
self.class_eval do
def bar
end
end
end
def foo
self.module_exec do
def bar
end
end
end
```
```ruby
# good
def foo
class << self
def bar
end
end
end
```
### References
* [https://github.com/bbatsov/ruby-style-guide#no-nested-methods](https://github.com/bbatsov/ruby-style-guide#no-nested-methods)
## Lint/NextWithoutAccumulator
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
Don't omit the accumulator when calling `next` in a `reduce` block.
### Example
```ruby
# bad
result = (1..4).reduce(0) do |acc, i|
next if i.odd?
acc + i
end
```
```ruby
# good
result = (1..4).reduce(0) do |acc, i|
next acc if i.odd?
acc + i
end
```
## Lint/NonLocalExitFromIterator
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for non-local exits from iterators without a return
value. It registers an offense under these conditions:
- No value is returned,
- the block is preceded by a method chain,
- the block has arguments,
- the method which receives the block is not `define_method`
or `define_singleton_method`,
- the return is not contained in an inner scope, e.g. a lambda or a
method definition.
### Example
```ruby
class ItemApi
rescue_from ValidationError do |e| # non-iteration block with arg
return message: 'validation error' unless e.errors # allowed
error_array = e.errors.map do |error| # block with method chain
return if error.suppress? # warned
return "#{error.param}: invalid" unless error.message # allowed
"#{error.param}: #{error.message}"
end
message: 'validation error', errors: error_array
end
def update_items
transaction do # block without arguments
return unless update_necessary? # allowed
find_each do |item| # block without method chain
return if item.stock == 0 # false-negative...
item.update!(foobar: true)
end
end
end
end
```
## Lint/ParenthesesAsGroupedExpression
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
Checks for space between a the name of a called method and a left
parenthesis.
### Example
```ruby
# bad
puts (x + y)
```
```ruby
# good
puts(x + y)
```
### References
* [https://github.com/bbatsov/ruby-style-guide#parens-no-spaces](https://github.com/bbatsov/ruby-style-guide#parens-no-spaces)
## Lint/PercentStringArray
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for quotes and commas in %w, e.g. `%w('foo', "bar")`
It is more likely that the additional characters are unintended (for
example, mistranslating an array of literals to percent string notation)
rather than meant to be part of the resulting strings.
### Example
```ruby
# bad
%w('foo', "bar")
```
```ruby
# good
%w(foo bar)
```
## Lint/PercentSymbolArray
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for colons and commas in %i, e.g. `%i(:foo, :bar)`
It is more likely that the additional characters are unintended (for
example, mistranslating an array of literals to percent string notation)
rather than meant to be part of the resulting symbols.
### Example
```ruby
# bad
%i(:foo, :bar)
```
```ruby
# good
%i(foo bar)
```
## Lint/RandOne
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for `rand(1)` calls.
Such calls always return `0`.
### Example
```ruby
# bad
rand 1
Kernel.rand(-1)
rand 1.0
rand(-1.0)
```
```ruby
# good
0 # just use 0 instead
```
## Lint/RequireParentheses
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for expressions where there is a call to a predicate
method with at least one argument, where no parentheses are used around
the parameter list, and a boolean operator, && or ||, is used in the
last argument.
The idea behind warning for these constructs is that the user might
be under the impression that the return value from the method call is
an operand of &&/||.
### Example
```ruby
# bad
if day.is? :tuesday && month == :jan
...
end
```
```ruby
# good
if day.is?(:tuesday) && month == :jan
```
## Lint/RescueException
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for *rescue* blocks targeting the Exception class.
### Example
```ruby
# bad
begin
do_something
rescue Exception
handle_exception
end
```
```ruby
# good
begin
do_something
rescue ArgumentError
handle_exception
end
```
### References
* [https://github.com/bbatsov/ruby-style-guide#no-blind-rescues](https://github.com/bbatsov/ruby-style-guide#no-blind-rescues)
## Lint/SafeNavigationChain
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
The safe navigation operator returns nil if the receiver is
nil. If you chain an ordinary method call after a safe
navigation operator, it raises NoMethodError. We should use a
safe navigation operator after a safe navigation operator.
This cop checks for the problem outlined above.
### Example
```ruby
# bad
x&.foo.bar
x&.foo + bar
x&.foo[bar]
```
```ruby
# good
x&.foo&.bar
x&.foo || bar
```
### Important attributes
Attribute | Value
--- | ---
Whitelist | present?, blank?, presence, try
## Lint/ShadowedException
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for a rescued exception that get shadowed by a
less specific exception being rescued before a more specific
exception is rescued.
### Example
```ruby
# bad
begin
something
rescue Exception
handle_exception
rescue StandardError
handle_standard_error
end
```
```ruby
# good
begin
something
rescue StandardError
handle_standard_error
rescue Exception
handle_exception
end
```
## Lint/ShadowingOuterLocalVariable
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop looks for use of the same name as outer local variables
for block arguments or block local variables.
This is a mimic of the warning
"shadowing outer local variable - foo" from `ruby -cw`.
### Example
```ruby
# bad
def some_method
foo = 1
2.times do |foo| # shadowing outer `foo`
do_something(foo)
end
end
```
```ruby
# good
def some_method
foo = 1
2.times do |bar|
do_something(bar)
end
end
```
## Lint/StringConversionInInterpolation
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for string conversion in string interpolation,
which is redundant.
### Example
```ruby
# bad
"result is #{something.to_s}"
```
```ruby
# good
"result is #{something}"
```
### References
* [https://github.com/bbatsov/ruby-style-guide#no-to-s](https://github.com/bbatsov/ruby-style-guide#no-to-s)
## Lint/UnderscorePrefixedVariableName
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for underscore-prefixed variables that are actually
used.
### Example
```ruby
# bad
[1, 2, 3].each do |_num|
do_something(_num)
end
```
```ruby
# good
[1, 2, 3].each do |num|
do_something(num)
end
```
```ruby
# good
[1, 2, 3].each do |_num|
do_something # not using `_num`
end
```
## Lint/UnifiedInteger
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for using Fixnum or Bignum constant.
### Example
```ruby
# bad
1.is_a?(Fixnum)
1.is_a?(Bignum)
```
```ruby
# good
1.is_a?(Integer)
```
## Lint/UnneededDisable
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop detects instances of rubocop:disable comments that can be
removed without causing any offenses to be reported. It's implemented
as a cop in that it inherits from the Cop base class and calls
add_offense. The unusual part of its implementation is that it doesn't
have any on_* methods or an investigate method. This means that it
doesn't take part in the investigation phase when the other cops do
their work. Instead, it waits until it's called in a later stage of the
execution. The reason it can't be implemented as a normal cop is that
it depends on the results of all other cops to do its work.
## Lint/UnneededSplatExpansion
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for unneeded usages of splat expansion
### Example
```ruby
# bad
a = *[1, 2, 3]
a = *'a'
a = *1
begin
foo
rescue *[StandardError, ApplicationError]
bar
end
case foo
when *[1, 2, 3]
bar
else
baz
end
```
```ruby
# good
c = [1, 2, 3]
a = *c
a, b = *c
a, *b = *c
a = *1..10
a = ['a']
begin
foo
rescue StandardError, ApplicationError
bar
end
case foo
when *[1, 2, 3]
bar
else
baz
end
```
## Lint/UnreachableCode
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for unreachable code.
The check are based on the presence of flow of control
statement in non-final position in *begin*(implicit) blocks.
### Example
```ruby
# bad
def some_method
return
do_something
end
```
```ruby
# good
def some_method
do_something
end
```
## Lint/UnusedBlockArgument
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for unused block arguments.
### Example
```ruby
# bad
do_something do |used, unused|
puts used
end
do_something do |bar|
puts :foo
end
define_method(:foo) do |bar|
puts :baz
end
```
```ruby
#good
do_something do |used, _unused|
puts used
end
do_something do
puts :foo
end
define_method(:foo) do |_bar|
puts :baz
end
```
### Important attributes
Attribute | Value
--- | ---
IgnoreEmptyBlocks | true
AllowUnusedKeywordArguments | false
### References
* [https://github.com/bbatsov/ruby-style-guide#underscore-unused-vars](https://github.com/bbatsov/ruby-style-guide#underscore-unused-vars)
## Lint/UnusedMethodArgument
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for unused method arguments.
### Example
```ruby
# bad
def some_method(used, unused, _unused_but_allowed)
puts used
end
```
```ruby
# good
def some_method(used, _unused, _unused_but_allowed)
puts used
end
```
### Important attributes
Attribute | Value
--- | ---
AllowUnusedKeywordArguments | false
IgnoreEmptyMethods | true
### References
* [https://github.com/bbatsov/ruby-style-guide#underscore-unused-vars](https://github.com/bbatsov/ruby-style-guide#underscore-unused-vars)
## Lint/UselessAccessModifier
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for redundant access modifiers, including those with no
code, those which are repeated, and leading `public` modifiers in a
class or module body. Conditionally-defined methods are considered as
always being defined, and thus access modifiers guarding such methods
are not redundant.
### Example
```ruby
class Foo
public # this is redundant (default access is public)
def method
end
private # this is not redundant (a method is defined)
def method2
end
private # this is redundant (no following methods are defined)
end
```
```ruby
class Foo
# The following is not redundant (conditionally defined methods are
# considered as always defining a method)
private
if condition?
def method
end
end
protected # this is not redundant (method is defined)
define_method(:method2) do
end
protected # this is redundant (repeated from previous modifier)
[1,2,3].each do |i|
define_method("foo#{i}") do
end
end
# The following is redundant (methods defined on the class'
# singleton class are not affected by the public modifier)
public
def self.method3
end
end
```
```ruby
# Lint/UselessAccessModifier:
# ContextCreatingMethods:
# - concerning
require 'active_support/concern'
class Foo
concerning :Bar do
def some_public_method
end
private
def some_private_method
end
end
# this is not redundant because `concerning` created its own context
private
def some_other_private_method
end
end
```
```ruby
# Lint/UselessAccessModifier:
# MethodCreatingMethods:
# - delegate
require 'active_support/core_ext/module/delegation'
class Foo
# this is not redundant because `delegate` creates methods
private
delegate :method_a, to: :method_b
end
```
### Important attributes
Attribute | Value
--- | ---
ContextCreatingMethods |
MethodCreatingMethods |
## Lint/UselessAssignment
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for every useless assignment to local variable in every
scope.
The basic idea for this cop was from the warning of `ruby -cw`:
assigned but unused variable - foo
Currently this cop has advanced logic that detects unreferenced
reassignments and properly handles varied cases such as branch, loop,
rescue, ensure, etc.
### Example
```ruby
# bad
def some_method
some_var = 1
do_something
end
```
```ruby
# good
def some_method
some_var = 1
do_something(some_var)
end
```
### References
* [https://github.com/bbatsov/ruby-style-guide#underscore-unused-vars](https://github.com/bbatsov/ruby-style-guide#underscore-unused-vars)
## Lint/UselessComparison
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for comparison of something with itself.
### Example
```ruby
# bad
x.top >= x.top
```
## Lint/UselessElseWithoutRescue
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for useless `else` in `begin..end` without `rescue`.
### Example
```ruby
# bad
begin
do_something
else
do_something_else # This will never be run.
end
```
```ruby
# good
begin
do_something
rescue
handle_errors
else
do_something_else
end
```
## Lint/UselessSetterCall
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for setter call to local variable as the final
expression of a function definition.
### Example
```ruby
# bad
def something
x = Something.new
x.attr = 5
end
```
```ruby
# good
def something
x = Something.new
x.attr = 5
x
end
```
## Lint/Void
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for operators, variables and literals used
in void context.
### Example
```ruby
# bad
def some_method
some_num * 10
do_something
end
```
```ruby
# bad
def some_method
some_var
do_something
end
```
```ruby
# good
def some_method
do_something
some_num * 10
end
```
```ruby
# good
def some_method
do_something
some_var
end
```
rubocop-0.48.1+dfsg.orig/manual/cops_metrics.md 0000664 0000000 0000000 00000012751 13070542236 0021434 0 ustar 00root root 0000000 0000000 # Metrics
## Metrics/AbcSize
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks that the ABC size of methods is not higher than the
configured maximum. The ABC size is based on assignments, branches
(method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric
### Important attributes
Attribute | Value
--- | ---
Max | 15
### References
* [http://c2.com/cgi/wiki?AbcMetric](http://c2.com/cgi/wiki?AbcMetric)
## Metrics/BlockLength
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks if the length of a block exceeds some maximum value.
Comment lines can optionally be ignored.
The maximum allowed length is configurable.
The cop can be configured to ignore blocks passed to certain methods.
### Important attributes
Attribute | Value
--- | ---
CountComments | false
Max | 25
ExcludedMethods |
## Metrics/BlockNesting
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for excessive nesting of conditional and looping
constructs.
You can configure if blocks are considered using the `CountBlocks`
option. When set to `false` (the default) blocks are not counted
towards the nesting level. Set to `true` to count blocks as well.
The maximum level of nesting allowed is configurable.
### Important attributes
Attribute | Value
--- | ---
CountBlocks | false
Max | 3
### References
* [https://github.com/bbatsov/ruby-style-guide#three-is-the-number-thou-shalt-count](https://github.com/bbatsov/ruby-style-guide#three-is-the-number-thou-shalt-count)
## Metrics/ClassLength
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks if the length a class exceeds some maximum value.
Comment lines can optionally be ignored.
The maximum allowed length is configurable.
### Important attributes
Attribute | Value
--- | ---
CountComments | false
Max | 100
## Metrics/CyclomaticComplexity
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks that the cyclomatic complexity of methods is not higher
than the configured maximum. The cyclomatic complexity is the number of
linearly independent paths through a method. The algorithm counts
decision points and adds one.
An if statement (or unless or ?:) increases the complexity by one. An
else branch does not, since it doesn't add a decision point. The &&
operator (or keyword and) can be converted to a nested if statement,
and ||/or is shorthand for a sequence of ifs, so they also add one.
Loops can be said to have an exit condition, so they add one.
### Important attributes
Attribute | Value
--- | ---
Max | 6
## Metrics/LineLength
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks the length of lines in the source code.
The maximum length is configurable.
### Important attributes
Attribute | Value
--- | ---
Max | 80
AllowHeredoc | true
AllowURI | true
URISchemes | http, https
IgnoreCopDirectives | false
IgnoredPatterns |
### References
* [https://github.com/bbatsov/ruby-style-guide#80-character-limits](https://github.com/bbatsov/ruby-style-guide#80-character-limits)
## Metrics/MethodLength
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks if the length of a method exceeds some maximum value.
Comment lines can optionally be ignored.
The maximum allowed length is configurable.
### Important attributes
Attribute | Value
--- | ---
CountComments | false
Max | 10
### References
* [https://github.com/bbatsov/ruby-style-guide#short-methods](https://github.com/bbatsov/ruby-style-guide#short-methods)
## Metrics/ModuleLength
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks if the length a module exceeds some maximum value.
Comment lines can optionally be ignored.
The maximum allowed length is configurable.
### Important attributes
Attribute | Value
--- | ---
CountComments | false
Max | 100
## Metrics/ParameterLists
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for methods with too many parameters.
The maximum number of parameters is configurable.
On Ruby 2.0+ keyword arguments can optionally
be excluded from the total count.
### Important attributes
Attribute | Value
--- | ---
Max | 5
CountKeywordArgs | true
### References
* [https://github.com/bbatsov/ruby-style-guide#too-many-params](https://github.com/bbatsov/ruby-style-guide#too-many-params)
## Metrics/PerceivedComplexity
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop tries to produce a complexity score that's a measure of the
complexity the reader experiences when looking at a method. For that
reason it considers `when` nodes as something that doesn't add as much
complexity as an `if` or a `&&`. Except if it's one of those special
`case`/`when` constructs where there's no expression after `case`. Then
the cop treats it as an `if`/`elsif`/`elsif`... and lets all the `when`
nodes count. In contrast to the CyclomaticComplexity cop, this cop
considers `else` nodes as adding complexity.
### Example
```ruby
def my_method # 1
if cond # 1
case var # 2 (0.8 + 4 * 0.2, rounded)
when 1 then func_one
when 2 then func_two
when 3 then func_three
when 4..10 then func_other
end
else # 1
do_something until a && b # 2
end # ===
end # 7 complexity points
```
### Important attributes
Attribute | Value
--- | ---
Max | 7
rubocop-0.48.1+dfsg.orig/manual/cops_performance.md 0000664 0000000 0000000 00000033656 13070542236 0022276 0 ustar 00root root 0000000 0000000 # Performance
## Performance/CaseWhenSplat
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Place `when` conditions that use splat at the end
of the list of `when` branches.
Ruby has to allocate memory for the splat expansion every time
that the `case` `when` statement is run. Since Ruby does not support
fall through inside of `case` `when`, like some other languages do,
the order of the `when` branches does not matter. By placing any
splat expansions at the end of the list of `when` branches we will
reduce the number of times that memory has to be allocated for
the expansion.
This is not a guaranteed performance improvement. If the data being
processed by the `case` condition is normalized in a manner that favors
hitting a condition in the splat expansion, it is possible that
moving the splat condition to the end will use more memory,
and run slightly slower.
### Example
```ruby
# bad
case foo
when *condition
bar
when baz
foobar
end
case foo
when *[1, 2, 3, 4]
bar
when 5
baz
end
# good
case foo
when baz
foobar
when *condition
bar
end
case foo
when 1, 2, 3, 4
bar
when 5
baz
end
```
## Performance/Casecmp
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop identifies places where a case-insensitive string comparison
can better be implemented using `casecmp`.
### Example
```ruby
# bad
str.downcase == 'abc'
str.upcase.eql? 'ABC'
'abc' == str.downcase
'ABC'.eql? str.upcase
str.downcase == str.downcase
# good
str.casecmp('ABC').zero?
'abc'.casecmp(str).zero?
```
### References
* [https://github.com/JuanitoFatas/fast-ruby#stringcasecmp-vs-stringdowncase---code](https://github.com/JuanitoFatas/fast-ruby#stringcasecmp-vs-stringdowncase---code)
## Performance/CompareWithBlock
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop identifies places where `sort { |a, b| a.foo <=> b.foo }`
can be replaced by `sort_by(&:foo)`.
This cop also checks `max` and `min` methods.
### Example
```ruby
# bad
array.sort { |a, b| a.foo <=> b.foo }
array.max { |a, b| a.foo <=> b.foo }
array.min { |a, b| a.foo <=> b.foo }
# good
array.sort_by(&:foo)
array.sort_by { |v| v.foo }
array.sort_by do |var|
var.foo
end
array.max_by(&:foo)
array.min_by(&:foo)
```
## Performance/Count
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop is used to identify usages of `count` on an `Enumerable` that
follow calls to `select` or `reject`. Querying logic can instead be
passed to the `count` call.
`ActiveRecord` compatibility:
`ActiveRecord` will ignore the block that is passed to `count`.
Other methods, such as `select`, will convert the association to an
array and then run the block on the array. A simple work around to
make `count` work with a block is to call `to_a.count {...}`.
Example:
Model.where(id: [1, 2, 3].select { |m| m.method == true }.size
becomes:
Model.where(id: [1, 2, 3]).to_a.count { |m| m.method == true }
### Example
```ruby
# bad
[1, 2, 3].select { |e| e > 2 }.size
[1, 2, 3].reject { |e| e > 2 }.size
[1, 2, 3].select { |e| e > 2 }.length
[1, 2, 3].reject { |e| e > 2 }.length
[1, 2, 3].select { |e| e > 2 }.count { |e| e.odd? }
[1, 2, 3].reject { |e| e > 2 }.count { |e| e.even? }
array.select(&:value).count
# good
[1, 2, 3].count { |e| e > 2 }
[1, 2, 3].count { |e| e < 2 }
[1, 2, 3].count { |e| e > 2 && e.odd? }
[1, 2, 3].count { |e| e < 2 && e.even? }
Model.select('field AS field_one').count
Model.select(:value).count
```
### Important attributes
Attribute | Value
--- | ---
SafeMode | true
## Performance/Detect
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop is used to identify usages of
`select.first`, `select.last`, `find_all.first`, and `find_all.last`
and change them to use `detect` instead.
`ActiveRecord` compatibility:
`ActiveRecord` does not implement a `detect` method and `find` has its
own meaning. Correcting ActiveRecord methods with this cop should be
considered unsafe.
### Example
```ruby
# bad
[].select { |item| true }.first
[].select { |item| true }.last
[].find_all { |item| true }.first
[].find_all { |item| true }.last
# good
[].detect { |item| true }
[].reverse.detect { |item| true }
```
### Important attributes
Attribute | Value
--- | ---
SafeMode | true
### References
* [https://github.com/JuanitoFatas/fast-ruby#enumerabledetect-vs-enumerableselectfirst-code](https://github.com/JuanitoFatas/fast-ruby#enumerabledetect-vs-enumerableselectfirst-code)
## Performance/DoubleStartEndWith
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for double `#start_with?` or `#end_with?` calls
separated by `||`. In some cases such calls can be replaced
with an single `#start_with?`/`#end_with?` call.
### Example
```ruby
# bad
str.start_with?("a") || str.start_with?(Some::CONST)
str.start_with?("a", "b") || str.start_with?("c")
var1 = ...
var2 = ...
str.end_with?(var1) || str.end_with?(var2)
# good
str.start_with?("a", Some::CONST)
str.start_with?("a", "b", "c")
var1 = ...
var2 = ...
str.end_with?(var1, var2)
```
### Important attributes
Attribute | Value
--- | ---
IncludeActiveSupportAliases | false
## Performance/EndWith
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop identifies unnecessary use of a regex where `String#end_with?`
would suffice.
### Example
```ruby
# bad
'abc' =~ /bc\Z/
'abc'.match(/bc\Z/)
# good
'abc'.end_with?('bc')
```
### Important attributes
Attribute | Value
--- | ---
AutoCorrect | false
### References
* [https://github.com/JuanitoFatas/fast-ruby#stringmatch-vs-stringstart_withstringend_with-code-start-code-end](https://github.com/JuanitoFatas/fast-ruby#stringmatch-vs-stringstart_withstringend_with-code-start-code-end)
## Performance/FixedSize
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
Do not compute the size of statically sized objects.
## Performance/FlatMap
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop is used to identify usages of
### Example
```ruby
# bad
[1, 2, 3, 4].map { |e| [e, e] }.flatten(1)
[1, 2, 3, 4].collect { |e| [e, e] }.flatten(1)
# good
[1, 2, 3, 4].flat_map { |e| [e, e] }
[1, 2, 3, 4].map { |e| [e, e] }.flatten
[1, 2, 3, 4].collect { |e| [e, e] }.flatten
```
### Important attributes
Attribute | Value
--- | ---
EnabledForFlattenWithoutParams | false
### References
* [https://github.com/JuanitoFatas/fast-ruby#enumerablemaparrayflatten-vs-enumerableflat_map-code](https://github.com/JuanitoFatas/fast-ruby#enumerablemaparrayflatten-vs-enumerableflat_map-code)
## Performance/HashEachMethods
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for uses of `each_key` & `each_value` Hash methods.
### Example
```ruby
# bad
hash.keys.each { |k| p k }
hash.values.each { |v| p v }
hash.each { |k, _v| p k }
hash.each { |_k, v| p v }
# good
hash.each_key { |k| p k }
hash.each_value { |v| p v }
```
### Important attributes
Attribute | Value
--- | ---
AutoCorrect | false
### References
* [https://github.com/bbatsov/ruby-style-guide#hash-each](https://github.com/bbatsov/ruby-style-guide#hash-each)
## Performance/LstripRstrip
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop identifies places where `lstrip.rstrip` can be replaced by
`strip`.
### Example
```ruby
# bad
'abc'.lstrip.rstrip
'abc'.rstrip.lstrip
# good
'abc'.strip
```
## Performance/RangeInclude
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop identifies uses of `Range#include?`, which iterates over each
item in a `Range` to see if a specified item is there. In contrast,
`Range#cover?` simply compares the target item with the beginning and
end points of the `Range`. In a great majority of cases, this is what
is wanted.
Here is an example of a case where `Range#cover?` may not provide the
desired result:
('a'..'z').cover?('yellow') # => true
### References
* [https://github.com/JuanitoFatas/fast-ruby#cover-vs-include-code](https://github.com/JuanitoFatas/fast-ruby#cover-vs-include-code)
## Performance/RedundantBlockCall
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop identifies the use of a `&block` parameter and `block.call`
where `yield` would do just as well.
### Example
```ruby
# bad
def method(&block)
block.call
end
def another(&func)
func.call 1, 2, 3
end
# good
def method
yield
end
def another
yield 1, 2, 3
end
```
### References
* [https://github.com/JuanitoFatas/fast-ruby#proccall-vs-yield-code](https://github.com/JuanitoFatas/fast-ruby#proccall-vs-yield-code)
## Performance/RedundantMatch
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop identifies use of `Regexp#match` or `String#match` in a context
where the integral return value of `=~` would do just as well.
### Example
```ruby
# bad
do_something if str.match(/regex/)
while regex.match('str')
do_something
end
# good
method(str.match(/regex/))
return regex.match('str')
```
## Performance/RedundantMerge
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop identifies places where `Hash#merge!` can be replaced by
`Hash#[]=`.
### Example
```ruby
hash.merge!(a: 1)
hash.merge!({'key' => 'value'})
hash.merge!(a: 1, b: 2)
```
### Important attributes
Attribute | Value
--- | ---
MaxKeyValuePairs | 2
### References
* [https://github.com/JuanitoFatas/fast-ruby#hashmerge-vs-hash-code](https://github.com/JuanitoFatas/fast-ruby#hashmerge-vs-hash-code)
## Performance/RedundantSortBy
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop identifies places where `sort_by { ... }` can be replaced by
`sort`.
### Example
```ruby
# bad
array.sort_by { |x| x }
array.sort_by do |var|
var
end
# good
array.sort
```
## Performance/RegexpMatch
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
In Ruby 2.4, `String#match?`, `Regexp#match?` and `Symbol#match?`
have been added. The methods are faster than `match`.
Because the methods avoid creating a `MatchData` object or saving
backref.
So, when `MatchData` is not used, use `match?` instead of `match`.
### Example
```ruby
# bad
def foo
if x =~ /re/
do_something
end
end
# bad
def foo
if x.match(/re/)
do_something
end
end
# bad
def foo
if /re/ === x
do_something
end
end
# good
def foo
if x.match?(/re/)
do_something
end
end
# good
def foo
if x =~ /re/
do_something(Regexp.last_match)
end
end
# good
def foo
if x.match(/re/)
do_something($~)
end
end
# good
def foo
if /re/ === x
do_something($~)
end
end
```
## Performance/ReverseEach
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop is used to identify usages of `reverse.each` and
change them to use `reverse_each` instead.
### Example
```ruby
# bad
[].reverse.each
# good
[].reverse_each
```
### References
* [https://github.com/JuanitoFatas/fast-ruby#enumerablereverseeach-vs-enumerablereverse_each-code](https://github.com/JuanitoFatas/fast-ruby#enumerablereverseeach-vs-enumerablereverse_each-code)
## Performance/Sample
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop is used to identify usages of `shuffle.first`, `shuffle.last`
and `shuffle[]` and change them to use `sample` instead.
### Example
```ruby
# bad
[1, 2, 3].shuffle.first
[1, 2, 3].shuffle.first(2)
[1, 2, 3].shuffle.last
[1, 2, 3].shuffle[2]
[1, 2, 3].shuffle[0, 2] # sample(2) will do the same
[1, 2, 3].shuffle[0..2] # sample(3) will do the same
[1, 2, 3].shuffle(random: Random.new).first
# good
[1, 2, 3].shuffle
[1, 2, 3].sample
[1, 2, 3].sample(3)
[1, 2, 3].shuffle[1, 3] # sample(3) might return a longer Array
[1, 2, 3].shuffle[1..3] # sample(3) might return a longer Array
[1, 2, 3].shuffle[foo, bar]
[1, 2, 3].shuffle(random: Random.new)
```
### References
* [https://github.com/JuanitoFatas/fast-ruby#arrayshufflefirst-vs-arraysample-code](https://github.com/JuanitoFatas/fast-ruby#arrayshufflefirst-vs-arraysample-code)
## Performance/Size
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop is used to identify usages of `count` on an
`Array` and `Hash` and change them to `size`.
TODO: Add advanced detection of variables that could
have been assigned to an array or a hash.
### Example
```ruby
# bad
[1, 2, 3].count
# bad
{a: 1, b: 2, c: 3}.count
# good
[1, 2, 3].size
# good
{a: 1, b: 2, c: 3}.size
# good
[1, 2, 3].count { |e| e > 2 }
```
### References
* [https://github.com/JuanitoFatas/fast-ruby#arraycount-vs-arraysize-code](https://github.com/JuanitoFatas/fast-ruby#arraycount-vs-arraysize-code)
## Performance/StartWith
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop identifies unnecessary use of a regex where
`String#start_with?` would suffice.
### Example
```ruby
# bad
'abc' =~ /\Aab/
'abc'.match(/\Aab/)
# good
'abc'.start_with?('ab')
```
### Important attributes
Attribute | Value
--- | ---
AutoCorrect | false
### References
* [https://github.com/JuanitoFatas/fast-ruby#stringmatch-vs-stringstart_withstringend_with-code-start-code-end](https://github.com/JuanitoFatas/fast-ruby#stringmatch-vs-stringstart_withstringend_with-code-start-code-end)
## Performance/StringReplacement
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop identifies places where `gsub` can be replaced by
`tr` or `delete`.
### Example
```ruby
# bad
'abc'.gsub('b', 'd')
'abc'.gsub('a', '')
'abc'.gsub(/a/, 'd')
'abc'.gsub!('a', 'd')
# good
'abc'.gsub(/.*/, 'a')
'abc'.gsub(/a+/, 'd')
'abc'.tr('b', 'd')
'a b c'.delete(' ')
```
### References
* [https://github.com/JuanitoFatas/fast-ruby#stringgsub-vs-stringtr-code](https://github.com/JuanitoFatas/fast-ruby#stringgsub-vs-stringtr-code)
## Performance/TimesMap
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for .times.map calls.
In most cases such calls can be replaced
with an explicit array creation.
### Example
```ruby
# bad
9.times.map do |i|
i.to_s
end
# good
Array.new(9) do |i|
i.to_s
end
```
rubocop-0.48.1+dfsg.orig/manual/cops_rails.md 0000664 0000000 0000000 00000046667 13070542236 0021115 0 ustar 00root root 0000000 0000000 # Rails
## Rails/ActionFilter
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop enforces the consistent use of action filter methods.
The cop is configurable and can enforce the use of the older
something_filter methods or the newer something_action methods.
If the TargetRailsVersion is set to less than 4.0, the cop will enforce
the use of filter methods.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | action
SupportedStyles | action, filter
Include | app/controllers/\*\*/\*.rb
## Rails/ActiveSupportAliases
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks that ActiveSupport aliases to core ruby methods
are not used.
### Example
```ruby
# good
'some_string'.start_with?('prefix')
'some_string'.end_with?('suffix')
[1, 2, 'a'] << 'b'
[1, 2, 'a'].unshift('b')
# bad
'some_string'.starts_with?('prefix')
'some_string'.ends_with?('suffix')
[1, 2, 'a'].append('b')
[1, 2, 'a'].prepend('b')
```
## Rails/Blank
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cops checks for code that can be changed to `blank?`.
Settings:
NilOrEmpty: Convert checks for `nil` or `empty?` to `blank?`
NotPresent: Convert usages of not `present?` to `blank?`
UnlessPresent: Convert usages of `unless` `present?` to `blank?`
### Example
```ruby
# NilOrEmpty: true
# bad
foo.nil? || foo.empty?
foo == nil || foo.empty?
# good
foo.blank?
# NotPresent: true
# bad
!foo.present?
# good
foo.blank?
# UnlessPresent: true
# bad
something unless foo.present?
unless foo.present?
something
end
# good
something if foo.blank?
if foo.blank?
something
end
```
### Important attributes
Attribute | Value
--- | ---
NilOrEmpty | true
NotPresent | true
UnlessPresent | true
## Rails/Date
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for the correct use of Date methods,
such as Date.today, Date.current etc.
Using Date.today is dangerous, because it doesn't know anything about
Rails time zone. You must use Time.zone.today instead.
The cop also reports warnings when you are using 'to_time' method,
because it doesn't know about Rails time zone either.
Two styles are supported for this cop. When EnforcedStyle is 'strict'
then the Date methods (today, current, yesterday, tomorrow)
are prohibited and the usage of both 'to_time'
and 'to_time_in_current_zone' is reported as warning.
When EnforcedStyle is 'flexible' then only 'Date.today' is prohibited
and only 'to_time' is reported as warning.
### Example
```ruby
# no offense
Time.zone.today
Time.zone.today - 1.day
# flexible
Date.current
Date.yesterday
# always reports offense
Date.today
date.to_time
# reports offense only when style is 'strict'
date.to_time_in_current_zone
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | flexible
SupportedStyles | strict, flexible
## Rails/Delegate
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop looks for delegations, that could have been created
automatically with delegate method.
### Example
```ruby
# bad
def bar
foo.bar
end
# good
delegate :bar, to: :foo
# bad
def foo_bar
foo.bar
end
# good
delegate :bar, to: :foo, prefix: true
# good
private
def bar
foo.bar
end
```
## Rails/DelegateAllowBlank
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop looks for delegations that pass :allow_blank as an option
instead of :allow_nil. :allow_blank is not a valid option to pass
to ActiveSupport#delegate.
### Example
```ruby
# bad
delegate :foo, to: :bar, allow_blank: true
# good
delegate :foo, to: :bar, allow_nil: true
```
## Rails/DynamicFindBy
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks dynamic `find_by_*` methods.
Use `find_by` instead of dynamic method.
See. https://github.com/bbatsov/rails-style-guide#find_by
### Example
```ruby
# bad
User.find_by_name(name)
# bad
User.find_by_name_and_email(name)
# bad
User.find_by_email!(name)
# good
User.find_by(name: name)
# good
User.find_by(name: name, email: email)
# good
User.find_by!(email: email)
```
### Important attributes
Attribute | Value
--- | ---
Whitelist | find_by_sql
### References
* [https://github.com/bbatsov/rails-style-guide#find_by](https://github.com/bbatsov/rails-style-guide#find_by)
## Rails/EnumUniqueness
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop looks for duplicate values in enum declarations.
### Example
```ruby
# bad
enum status: { active: 0, archived: 0 }
# good
enum status: { active: 0, archived: 1 }
# bad
enum status: [:active, :archived, :active]
# good
enum status: [:active, :archived]
```
### Important attributes
Attribute | Value
--- | ---
Include | app/models/\*\*/\*.rb
## Rails/Exit
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop enforces that 'exit' calls are not used within a rails app.
Valid options are instead to raise an error, break, return or some
other form of stopping execution of current request.
There are two obvious cases where 'exit' is particularly harmful:
- Usage in library code for your application. Even though rails will
rescue from a SystemExit and continue on, unit testing that library
code will result in specs exiting (potentially silently if exit(0)
is used.)
- Usage in application code outside of the web process could result in
the program exiting, which could result in the code failing to run and
do its job.
### Important attributes
Attribute | Value
--- | ---
Include | app/\*\*/\*.rb, config/\*\*/\*.rb, lib/\*\*/\*.rb
Exclude | lib/\*\*/\*.rake
## Rails/FilePath
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop is used to identify usages of file path joining process
to use `Rails.root.join` clause.
### Example
```ruby
# bad
Rails.root.join('app/models/goober')
File.join(Rails.root, 'app/models/goober')
"#{Rails.root}/app/models/goober"
# good
Rails.root.join('app', 'models', 'goober')
```
## Rails/FindBy
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop is used to identify usages of `where.first` and
change them to use `find_by` instead.
### Example
```ruby
# bad
User.where(name: 'Bruce').first
User.where(name: 'Bruce').take
# good
User.find_by(name: 'Bruce')
```
### Important attributes
Attribute | Value
--- | ---
Include | app/models/\*\*/\*.rb
### References
* [https://github.com/bbatsov/rails-style-guide#find_by](https://github.com/bbatsov/rails-style-guide#find_by)
## Rails/FindEach
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop is used to identify usages of `all.each` and
change them to use `all.find_each` instead.
### Example
```ruby
# bad
User.all.each
# good
User.all.find_each
```
### Important attributes
Attribute | Value
--- | ---
Include | app/models/\*\*/\*.rb
### References
* [https://github.com/bbatsov/rails-style-guide#find-each](https://github.com/bbatsov/rails-style-guide#find-each)
## Rails/HasAndBelongsToMany
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for the use of the has_and_belongs_to_many macro.
### Important attributes
Attribute | Value
--- | ---
Include | app/models/\*\*/\*.rb
### References
* [https://github.com/bbatsov/rails-style-guide#has-many-through](https://github.com/bbatsov/rails-style-guide#has-many-through)
## Rails/HttpPositionalArguments
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop is used to identify usages of http methods like `get`, `post`,
`put`, `patch` without the usage of keyword arguments in your tests and
change them to use keyword args. This cop only applies to Rails >= 5 .
If you are not running Rails < 5 you should disable # the
Rails/HttpPositionalArguments cop or set your TargetRailsVersion in your
.rubocop.yml file to 4.0, etc.
### Example
```ruby
# bad
get :new, { user_id: 1}
# good
get :new, params: { user_id: 1 }
```
### Important attributes
Attribute | Value
--- | ---
Include | spec/\*\*/\*, test/\*\*/\*
## Rails/NotNullColumn
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for add_column call with NOT NULL constraint
in migration file.
### Example
```ruby
# bad
add_column :users, :name, :string, null: false
add_reference :products, :category, null: false
# good
add_column :users, :name, :string, null: true
add_column :users, :name, :string, null: false, default: ''
add_reference :products, :category
add_reference :products, :category, null: false, default: 1
```
### Important attributes
Attribute | Value
--- | ---
Include | db/migrate/\*.rb
## Rails/Output
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for the use of output calls like puts and print
### Important attributes
Attribute | Value
--- | ---
Include | app/\*\*/\*.rb, config/\*\*/\*.rb, db/\*\*/\*.rb, lib/\*\*/\*.rb
## Rails/OutputSafety
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for the use of output safety calls like html_safe and
raw.
### Example
```ruby
# bad
"#{text}
".html_safe
# good
content_tag(:p, text)
# bad
out = ""
out << content_tag(:li, "one")
out << content_tag(:li, "two")
out.html_safe
# good
out = []
out << content_tag(:li, "one")
out << content_tag(:li, "two")
safe_join(out)
```
## Rails/PluralizationGrammar
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for correct grammar when using ActiveSupport's
core extensions to the numeric classes.
### Example
```ruby
# bad
3.day.ago
1.months.ago
# good
3.days.ago
1.month.ago
```
## Rails/Present
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cops checks for code that can be changed to `blank?`.
Settings:
NotNilAndNotEmpty: Convert checks for not `nil` and `not empty?`
to `present?`
NotBlank: Convert usages of not `blank?` to `present?`
UnlessBlank: Convert usages of `unless` `blank?` to `if` `present?`
### Example
```ruby
# NotNilAndNotEmpty: true
# bad
!foo.nil? && !foo.empty?
foo != nil && !foo.empty?
!foo.blank?
# good
foo.present?
# NotBlank: true
# bad
!foo.blank?
not foo.blank?
# good
foo.present?
# UnlessBlank: true
# bad
something unless foo.blank?
# good
something if foo.present?
```
### Important attributes
Attribute | Value
--- | ---
NotNilAndNotEmpty | true
NotBlank | true
UnlessBlank | true
## Rails/ReadWriteAttribute
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for the use of the read_attribute or
write_attribute methods.
### Example
```ruby
# bad
x = read_attribute(:attr)
write_attribute(:attr, val)
# good
x = self[:attr]
self[:attr] = val
```
### Important attributes
Attribute | Value
--- | ---
Include | app/models/\*\*/\*.rb
### References
* [https://github.com/bbatsov/rails-style-guide#read-attribute](https://github.com/bbatsov/rails-style-guide#read-attribute)
## Rails/RelativeDateConstant
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks whether constant value isn't relative date.
Because the relative date will be evaluated only once.
### Example
```ruby
# bad
class SomeClass
EXPIRED_AT = 1.week.since
end
# good
class SomeClass
def self.expired_at
1.week.since
end
end
```
## Rails/RequestReferer
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for consistent uses of `request.referer` or
`request.referrer`, depending on the cop's configuration.
### Example
```ruby
# EnforcedStyle: referer
# bad
request.referrer
# good
request.referer
# EnforcedStyle: referrer
# bad
request.referer
# good
request.referrer
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | referer
SupportedStyles | referer, referrer
## Rails/ReversibleMigration
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks whether the change method of the migration file is
reversible.
### Example
```ruby
# bad
def change
change_table :users do |t|
t.column :name, :string
end
end
# good
def change
create_table :users do |t|
t.string :name
end
end
# good
def change
reversible do |dir|
change_table :users do |t|
dir.up do
t.column :name, :string
end
dir.down do
t.remove :name
end
end
end
end
```
```ruby
# drop_table
# bad
def change
drop_table :users
end
# good
def change
drop_table :users do |t|
t.string :name
end
end
```
```ruby
# change_column_default
# bad
def change
change_column_default(:suppliers, :qualification, 'new')
end
# good
def change
change_column_default(:posts, :state, from: nil, to: "draft")
end
```
```ruby
# remove_column
# bad
def change
remove_column(:suppliers, :qualification)
end
# good
def change
remove_column(:suppliers, :qualification, :string)
end
```
```ruby
# remove_foreign_key
# bad
def change
remove_foreign_key :accounts, column: :owner_id
end
# good
def change
remove_foreign_key :accounts, :branches
end
```
### Important attributes
Attribute | Value
--- | ---
Include | db/migrate/\*.rb
### References
* [https://github.com/bbatsov/rails-style-guide#reversible-migration](https://github.com/bbatsov/rails-style-guide#reversible-migration)
* [http://api.rubyonrails.org/classes/ActiveRecord/Migration/CommandRecorder.html](http://api.rubyonrails.org/classes/ActiveRecord/Migration/CommandRecorder.html)
## Rails/SafeNavigation
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop converts usages of `try!` to `&.`. It can also be configured
to convert `try`. It will convert code to use safe navigation if the
target Ruby version is set to 2.3+
### Example
```ruby
# ConvertTry: false
# bad
foo.try!(:bar)
foo.try!(:bar, baz)
foo.try!(:bar) { |e| e.baz }
foo.try!(:[], 0)
# good
foo.try(:bar)
foo.try(:bar, baz)
foo.try(:bar) { |e| e.baz }
foo&.bar
foo&.bar(baz)
foo&.bar { |e| e.baz }
# ConvertTry: true
# bad
foo.try!(:bar)
foo.try!(:bar, baz)
foo.try!(:bar) { |e| e.baz }
foo.try(:bar)
foo.try(:bar, baz)
foo.try(:bar) { |e| e.baz }
# good
foo&.bar
foo&.bar(baz)
foo&.bar { |e| e.baz }
```
### Important attributes
Attribute | Value
--- | ---
ConvertTry | false
## Rails/SaveBang
Enabled by default | Supports autocorrection
--- | ---
Disabled | Yes
This cop identifies possible cases where Active Record save! or related
should be used instead of save because the model might have failed to
save and an exception is better than unhandled failure.
This will ignore calls that return a boolean for success if the result
is assigned to a variable or used as the condition in an if/unless
statement. It will also ignore calls that return a model assigned to a
variable that has a call to `persisted?`. Finally, it will ignore any
call with more than 2 arguments as that is likely not an Active Record
call or a Model.update(id, attributes) call.
### Example
```ruby
# bad
user.save
user.update(name: 'Joe')
user.find_or_create_by(name: 'Joe')
user.destroy
# good
unless user.save
. . .
end
user.save!
user.update!(name: 'Joe')
user.find_or_create_by!(name: 'Joe')
user.destroy!
user = User.find_or_create_by(name: 'Joe')
unless user.persisted?
. . .
end
```
### References
* [https://github.com/bbatsov/rails-style-guide#save-bang](https://github.com/bbatsov/rails-style-guide#save-bang)
## Rails/ScopeArgs
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for scope calls where it was passed
a method (usually a scope) instead of a lambda/proc.
### Example
```ruby
# bad
scope :something, where(something: true)
# good
scope :something, -> { where(something: true) }
```
### Important attributes
Attribute | Value
--- | ---
Include | app/models/\*\*/\*.rb
## Rails/SkipsModelValidations
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for the use of methods which skip
validations which are listed in
http://guides.rubyonrails.org/active_record_validations.html#skipping-validations
### Example
```ruby
# bad
Article.first.decrement!(:view_count)
DiscussionBoard.decrement_counter(:post_count, 5)
Article.first.increment!(:view_count)
DiscussionBoard.increment_counter(:post_count, 5)
person.toggle :active
product.touch
Billing.update_all("category = 'authorized', author = 'David'")
user.update_attribute(website: 'example.com')
user.update_columns(last_request_at: Time.current)
Post.update_counters 5, comment_count: -1, action_count: 1
# good
user.update_attributes(website: 'example.com')
```
### Important attributes
Attribute | Value
--- | ---
Blacklist | decrement!, decrement_counter, increment!, increment_counter, toggle!, touch, update_all, update_attribute, update_column, update_columns, update_counters
### References
* [http://guides.rubyonrails.org/active_record_validations.html#skipping-validations](http://guides.rubyonrails.org/active_record_validations.html#skipping-validations)
## Rails/TimeZone
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for the use of Time methods without zone.
Built on top of Ruby on Rails style guide (https://github.com/bbatsov/rails-style-guide#time)
and the article http://danilenko.org/2012/7/6/rails_timezones/ .
Two styles are supported for this cop. When EnforcedStyle is 'strict'
then only use of Time.zone is allowed.
When EnforcedStyle is 'flexible' then it's also allowed
to use Time.in_time_zone.
### Example
```ruby
# always offense
Time.now
Time.parse('2015-03-02 19:05:37')
# no offense
Time.zone.now
Time.zone.parse('2015-03-02 19:05:37')
# no offense only if style is 'flexible'
Time.current
DateTime.strptime(str, "%Y-%m-%d %H:%M %Z").in_time_zone
Time.at(timestamp).in_time_zone
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | flexible
SupportedStyles | strict, flexible
### References
* [https://github.com/bbatsov/rails-style-guide#time](https://github.com/bbatsov/rails-style-guide#time)
* [http://danilenko.org/2012/7/6/rails_timezones](http://danilenko.org/2012/7/6/rails_timezones)
## Rails/UniqBeforePluck
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Prefer the use of uniq (or distinct), before pluck instead of after.
The use of uniq before pluck is preferred because it executes within
the database.
This cop has two different enforcement modes. When the EnforcedStyle
is conservative (the default) then only calls to pluck on a constant
(i.e. a model class) before uniq are added as offenses.
When the EnforcedStyle is aggressive then all calls to pluck before
uniq are added as offenses. This may lead to false positives as the cop
cannot distinguish between calls to pluck on an ActiveRecord::Relation
vs a call to pluck on an ActiveRecord::Associations::CollectionProxy.
Autocorrect is disabled by default for this cop since it may generate
false positives.
### Example
```ruby
# bad
Model.pluck(:id).uniq
# good
Model.uniq.pluck(:id)
```
```ruby
# this will return a Relation that pluck is called on
Model.where(...).pluck(:id).uniq
# an association on an instance will return a CollectionProxy
instance.assoc.pluck(:id).uniq
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | conservative
SupportedStyles | conservative, aggressive
AutoCorrect | false
## Rails/Validation
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for the use of old-style attribute validation macros.
### Important attributes
Attribute | Value
--- | ---
Include | app/models/\*\*/\*.rb
rubocop-0.48.1+dfsg.orig/manual/cops_security.md 0000664 0000000 0000000 00000004414 13070542236 0021632 0 ustar 00root root 0000000 0000000 # Security
## Security/Eval
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for the use of *Kernel#eval*.
### Example
```ruby
# bad
eval(something)
```
## Security/JSONLoad
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for the use of JSON class methods which have potential
security issues.
Autocorrect is disabled by default because it's potentially dangerous.
If using a stream, like `JSON.load(open('file'))`, it will need to call
`#read` manually, like `JSON.parse(open('file').read)`.
If reading single values (rather than proper JSON objects), like
`JSON.load('false')`, it will need to pass the `quirks_mode: true`
option, like `JSON.parse('false', quirks_mode: true)`.
Other similar issues may apply.
### Example
```ruby
# always offense
JSON.load("{}")
JSON.restore("{}")
# no offense
JSON.parse("{}")
```
### Important attributes
Attribute | Value
--- | ---
AutoCorrect | false
### References
* [http://ruby-doc.org/stdlib-2.3.0/libdoc/json/rdoc/JSON.html#method-i-load](http://ruby-doc.org/stdlib-2.3.0/libdoc/json/rdoc/JSON.html#method-i-load)
## Security/MarshalLoad
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for the use of Marshal class methods which have
potential security issues leading to remote code execution when
loading from an untrusted source.
### Example
```ruby
# bad
Marshal.load("{}")
Marshal.restore("{}")
# good
Marshal.dump("{}")
# okish - deep copy hack
Marshal.load(Marshal.dump({}))
```
### References
* [http://ruby-doc.org/core-2.3.3/Marshal.html#module-Marshal-label-Security+considerations](http://ruby-doc.org/core-2.3.3/Marshal.html#module-Marshal-label-Security+considerations)
## Security/YAMLLoad
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for the use of YAML class methods which have
potential security issues leading to remote code execution when
loading from an untrusted source.
### Example
```ruby
# bad
YAML.load("--- foo")
# good
YAML.safe_load("--- foo")
YAML.dump("foo")
```
### References
* [https://ruby-doc.org/stdlib-2.3.3/libdoc/yaml/rdoc/YAML.html#module-YAML-label-Security](https://ruby-doc.org/stdlib-2.3.3/libdoc/yaml/rdoc/YAML.html#module-YAML-label-Security)
rubocop-0.48.1+dfsg.orig/manual/cops_style.md 0000664 0000000 0000000 00000337071 13070542236 0021133 0 ustar 00root root 0000000 0000000 # Style
## Style/AccessModifierIndentation
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Modifiers should be indented as deep as method definitions, or as deep
as the class/module keyword, depending on configuration.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | indent
SupportedStyles | outdent, indent
IndentationWidth |
### References
* [https://github.com/bbatsov/ruby-style-guide#indent-public-private-protected](https://github.com/bbatsov/ruby-style-guide#indent-public-private-protected)
## Style/AccessorMethodName
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop makes sure that accessor methods are named properly.
### Example
```ruby
# bad
def set_attribute(value) ...
# good
def attribute=(value)
# bad
def get_attribute ...
# good
def attribute ...
```
### References
* [https://github.com/bbatsov/ruby-style-guide#accessor_mutator_method_names](https://github.com/bbatsov/ruby-style-guide#accessor_mutator_method_names)
## Style/Alias
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop finds uses of `alias` where `alias_method` would be more
appropriate (or is simply preferred due to configuration), and vice
versa.
It also finds uses of `alias :symbol` rather than `alias bareword`.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | prefer_alias
SupportedStyles | prefer_alias, prefer_alias_method
### References
* [https://github.com/bbatsov/ruby-style-guide#alias-method](https://github.com/bbatsov/ruby-style-guide#alias-method)
## Style/AlignArray
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Here we check if the elements of a multi-line array literal are
aligned.
### References
* [https://github.com/bbatsov/ruby-style-guide#align-multiline-arrays](https://github.com/bbatsov/ruby-style-guide#align-multiline-arrays)
## Style/AlignHash
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Check that the keys, separators, and values of a multi-line hash
literal are aligned according to configuration. The configuration
options are:
- key (left align keys)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)
The treatment of hashes passed as the last argument to a method call
can also be configured. The options are:
- always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)
### Example
```ruby
# EnforcedHashRocketStyle: key (default)
# EnforcedColonStyle: key (default)
# good
{
foo: bar,
ba: baz
}
{
:foo => bar,
:ba => baz
}
# bad
{
foo: bar,
ba: baz
}
{
:foo => bar,
:ba => baz
}
```
```ruby
# EnforcedHashRocketStyle: separator
# EnforcedColonStyle: separator
#good
{
foo: bar,
ba: baz
}
{
:foo => bar,
:ba => baz
}
#bad
{
foo: bar,
ba: baz
}
{
:foo => bar,
:ba => baz
}
{
:foo => bar,
:ba => baz
}
```
```ruby
# EnforcedHashRocketStyle: table
# EnforcedColonStyle: table
#good
{
foo: bar,
ba: baz
}
{
:foo => bar,
:ba => baz
}
#bad
{
foo: bar,
ba: baz
}
{
:foo => bar,
:ba => baz
}
```
### Important attributes
Attribute | Value
--- | ---
EnforcedHashRocketStyle | key
SupportedHashRocketStyles | key, separator, table
EnforcedColonStyle | key
SupportedColonStyles | key, separator, table
EnforcedLastArgumentHashStyle | always_inspect
SupportedLastArgumentHashStyles | always_inspect, always_ignore, ignore_implicit, ignore_explicit
## Style/AlignParameters
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Here we check if the parameters on a multi-line method call or
definition are aligned.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | with_first_parameter
SupportedStyles | with_first_parameter, with_fixed_indentation
IndentationWidth |
### References
* [https://github.com/bbatsov/ruby-style-guide#no-double-indent](https://github.com/bbatsov/ruby-style-guide#no-double-indent)
## Style/AndOr
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for uses of *and* and *or*.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | always
SupportedStyles | always, conditionals
### References
* [https://github.com/bbatsov/ruby-style-guide#no-and-or-or](https://github.com/bbatsov/ruby-style-guide#no-and-or-or)
## Style/ArrayJoin
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for uses of "*" as a substitute for *join*.
Not all cases can reliably checked, due to Ruby's dynamic
types, so we consider only cases when the first argument is an
array literal or the second is a string literal.
### References
* [https://github.com/bbatsov/ruby-style-guide#array-join](https://github.com/bbatsov/ruby-style-guide#array-join)
## Style/AsciiComments
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for non-ascii (non-English) characters
in comments.
### References
* [https://github.com/bbatsov/ruby-style-guide#english-comments](https://github.com/bbatsov/ruby-style-guide#english-comments)
## Style/AsciiIdentifiers
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for non-ascii characters in identifier names.
### References
* [https://github.com/bbatsov/ruby-style-guide#english-identifiers](https://github.com/bbatsov/ruby-style-guide#english-identifiers)
## Style/Attr
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for uses of Module#attr.
### References
* [https://github.com/bbatsov/ruby-style-guide#attr](https://github.com/bbatsov/ruby-style-guide#attr)
## Style/AutoResourceCleanup
Enabled by default | Supports autocorrection
--- | ---
Disabled | No
This cop checks for cases when you could use a block
accepting version of a method that does automatic
resource cleanup.
### Example
```ruby
# bad
f = File.open('file')
# good
f = File.open('file') do
...
end
```
## Style/BarePercentLiterals
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks if usage of %() or %Q() matches configuration.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | bare_percent
SupportedStyles | percent_q, bare_percent
### References
* [https://github.com/bbatsov/ruby-style-guide#percent-q-shorthand](https://github.com/bbatsov/ruby-style-guide#percent-q-shorthand)
## Style/BeginBlock
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for BEGIN blocks.
### References
* [https://github.com/bbatsov/ruby-style-guide#no-BEGIN-blocks](https://github.com/bbatsov/ruby-style-guide#no-BEGIN-blocks)
## Style/BlockComments
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop looks for uses of block comments (=begin...=end).
### References
* [https://github.com/bbatsov/ruby-style-guide#no-block-comments](https://github.com/bbatsov/ruby-style-guide#no-block-comments)
## Style/BlockDelimiters
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Check for uses of braces or do/end around single line or
multi-line blocks.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | line_count_based
SupportedStyles | line_count_based, semantic, braces_for_chaining
ProceduralMethods | benchmark, bm, bmbm, create, each_with_object, measure, new, realtime, tap, with_object
FunctionalMethods | let, let!, subject, watch
IgnoredMethods | lambda, proc, it
### References
* [https://github.com/bbatsov/ruby-style-guide#single-line-blocks](https://github.com/bbatsov/ruby-style-guide#single-line-blocks)
## Style/BlockEndNewline
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks whether the end statement of a do..end block
is on its own line.
### Example
```ruby
# bad
blah do |i|
foo(i) end
# good
blah do |i|
foo(i)
end
# bad
blah { |i|
foo(i) }
# good
blah { |i|
foo(i)
}
```
## Style/BracesAroundHashParameters
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for braces around the last parameter in a method call
if the last parameter is a hash.
It supports 3 styles:
* The `braces` style enforces braces around all method
parameters that are hashes.
* The `no_braces` style checks that the last parameter doesn't
have braces around it.
* The `context_dependent` style checks that the last parameter
doesn't have braces around it, but requires braces if the
second to last parameter is also a hash literal.
### Example
```ruby
# bad
some_method(x, y, a: 1, b: 2)
# good
some_method(x, y, {a: 1, b: 2})
```
```ruby
# bad
some_method(x, y, {a: 1, b: 2})
# good
some_method(x, y, a: 1, b: 2)
```
```ruby
# bad
some_method(x, y, {a: 1, b: 2})
some_method(x, y, {a: 1, b: 2}, a: 1, b: 2)
# good
some_method(x, y, a: 1, b: 2)
some_method(x, y, {a: 1, b: 2}, {a: 1, b: 2})
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | no_braces
SupportedStyles | braces, no_braces, context_dependent
## Style/CaseEquality
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for uses of the case equality operator(===).
### References
* [https://github.com/bbatsov/ruby-style-guide#no-case-equality](https://github.com/bbatsov/ruby-style-guide#no-case-equality)
## Style/CaseIndentation
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks how the *when*s of a *case* expression
are indented in relation to its *case* or *end* keyword.
It will register a separate offense for each misaligned *when*.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | case
SupportedStyles | case, end
IndentOneStep | false
IndentationWidth |
### References
* [https://github.com/bbatsov/ruby-style-guide#indent-when-to-case](https://github.com/bbatsov/ruby-style-guide#indent-when-to-case)
## Style/CharacterLiteral
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks for uses of the character literal ?x.
### References
* [https://github.com/bbatsov/ruby-style-guide#no-character-literals](https://github.com/bbatsov/ruby-style-guide#no-character-literals)
## Style/ClassAndModuleCamelCase
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cops checks for class and module names with
an underscore in them.
### References
* [https://github.com/bbatsov/ruby-style-guide#camelcase-classes](https://github.com/bbatsov/ruby-style-guide#camelcase-classes)
## Style/ClassAndModuleChildren
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks the style of children definitions at classes and
modules. Basically there are two different styles:
nested - have each child on its own line
class Foo
class Bar
end
end
compact - combine definitions as much as possible
class Foo::Bar
end
The compact style is only forced for classes/modules with one child.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | nested
SupportedStyles | nested, compact
## Style/ClassCheck
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop enforces consistent use of `Object#is_a?` or `Object#kind_of?`.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | is_a?
SupportedStyles | is_a?, kind_of?
## Style/ClassMethods
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for uses of the class/module name instead of
self, when defining class/module methods.
### Example
```ruby
# bad
class SomeClass
def SomeClass.class_method
...
end
end
# good
class SomeClass
def self.class_method
...
end
end
```
### References
* [https://github.com/bbatsov/ruby-style-guide#def-self-class-methods](https://github.com/bbatsov/ruby-style-guide#def-self-class-methods)
## Style/ClassVars
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for uses of class variables. Offenses
are signaled only on assignment to class variables to
reduced the number of offenses that would be reported.
### References
* [https://github.com/bbatsov/ruby-style-guide#no-class-vars](https://github.com/bbatsov/ruby-style-guide#no-class-vars)
## Style/ClosingParenthesisIndentation
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cops checks the indentation of hanging closing parentheses in
method calls, method definitions, and grouped expressions. A hanging
closing parenthesis means `)` preceded by a line break.
### Example
```ruby
# good: when x is on its own line, indent this way
func(
x,
y
)
# good: when x follows opening parenthesis, align parentheses
a = b * (x +
y
)
# bad
def func(
x,
y
)
```
## Style/CollectionMethods
Enabled by default | Supports autocorrection
--- | ---
Disabled | Yes
This cop enforces the use of consistent method names
from the Enumerable module.
Unfortunately we cannot actually know if a method is from
Enumerable or not (static analysis limitation), so this cop
can yield some false positives.
### Important attributes
Attribute | Value
--- | ---
PreferredMethods | {"collect"=>"map", "collect!"=>"map!", "inject"=>"reduce", "detect"=>"find", "find_all"=>"select"}
### References
* [https://github.com/bbatsov/ruby-style-guide#map-find-select-reduce-size](https://github.com/bbatsov/ruby-style-guide#map-find-select-reduce-size)
## Style/ColonMethodCall
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for methods invoked via the :: operator instead
of the . operator (like FileUtils::rmdir instead of FileUtils.rmdir).
### References
* [https://github.com/bbatsov/ruby-style-guide#double-colons](https://github.com/bbatsov/ruby-style-guide#double-colons)
## Style/CommandLiteral
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop enforces using `` or %x around command literals.
### Example
```ruby
# Good if EnforcedStyle is backticks or mixed, bad if percent_x.
folders = `find . -type d`.split
# Good if EnforcedStyle is percent_x, bad if backticks or mixed.
folders = %x(find . -type d).split
# Good if EnforcedStyle is backticks, bad if percent_x or mixed.
`
ln -s foo.example.yml foo.example
ln -s bar.example.yml bar.example
`
# Good if EnforcedStyle is percent_x or mixed, bad if backticks.
%x(
ln -s foo.example.yml foo.example
ln -s bar.example.yml bar.example
)
# Bad unless AllowInnerBackticks is true.
`echo \`ls\``
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | backticks
SupportedStyles | backticks, percent_x, mixed
AllowInnerBackticks | false
### References
* [https://github.com/bbatsov/ruby-style-guide#percent-x](https://github.com/bbatsov/ruby-style-guide#percent-x)
## Style/CommentAnnotation
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks that comment annotation keywords are written according
to guidelines.
### Important attributes
Attribute | Value
--- | ---
Keywords | TODO, FIXME, OPTIMIZE, HACK, REVIEW
### References
* [https://github.com/bbatsov/ruby-style-guide#annotate-keywords](https://github.com/bbatsov/ruby-style-guide#annotate-keywords)
## Style/CommentIndentation
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cops checks the indentation of comments.
## Style/ConditionalAssignment
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Check for `if` and `case` statements where each branch is used for
assignment to the same variable when using the return of the
condition can be used instead.
### Example
```ruby
EnforcedStyle: assign_to_condition
# bad
if foo
bar = 1
else
bar = 2
end
case foo
when 'a'
bar += 1
else
bar += 2
end
if foo
some_method
bar = 1
else
some_other_method
bar = 2
end
# good
bar = if foo
1
else
2
end
bar += case foo
when 'a'
1
else
2
end
bar << if foo
some_method
1
else
some_other_method
2
end
EnforcedStyle: assign_inside_condition
# bad
bar = if foo
1
else
2
end
bar += case foo
when 'a'
1
else
2
end
bar << if foo
some_method
1
else
some_other_method
2
end
# good
if foo
bar = 1
else
bar = 2
end
case foo
when 'a'
bar += 1
else
bar += 2
end
if foo
some_method
bar = 1
else
some_other_method
bar = 2
end
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | assign_to_condition
SupportedStyles | assign_to_condition, assign_inside_condition
SingleLineConditionsOnly | true
IncludeTernaryExpressions | true
## Style/ConstantName
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks whether constant names are written using
SCREAMING_SNAKE_CASE.
To avoid false positives, it ignores cases in which we cannot know
for certain the type of value that would be assigned to a constant.
### References
* [https://github.com/bbatsov/ruby-style-guide#screaming-snake-case](https://github.com/bbatsov/ruby-style-guide#screaming-snake-case)
## Style/Copyright
Enabled by default | Supports autocorrection
--- | ---
Disabled | Yes
Check that a copyright notice was given in each source file.
The default regexp for an acceptable copyright notice can be found in
config/default.yml. The default can be changed as follows:
Style/Copyright:
Notice: '^Copyright (\(c\) )?2\d{3} Acme Inc'
This regex string is treated as an unanchored regex. For each file
that RuboCop scans, a comment that matches this regex must be found or
an offense is reported.
### Important attributes
Attribute | Value
--- | ---
Notice | ^Copyright (\(c\) )?2[0-9]{3} .+
AutocorrectNotice |
## Style/DefWithParentheses
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for parentheses in the definition of a method,
that does not take any arguments. Both instance and
class/singleton methods are checked.
### References
* [https://github.com/bbatsov/ruby-style-guide#method-parens](https://github.com/bbatsov/ruby-style-guide#method-parens)
## Style/Documentation
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for missing top-level documentation of
classes and modules. Classes with no body are exempt from the
check and so are namespace modules - modules that have nothing in
their bodies except classes, other modules, or constant definitions.
The documentation requirement is annulled if the class or module has
a "#:nodoc:" comment next to it. Likewise, "#:nodoc: all" does the
same for all its children.
### Important attributes
Attribute | Value
--- | ---
Exclude | spec/\*\*/\*, test/\*\*/\*
## Style/DocumentationMethod
Enabled by default | Supports autocorrection
--- | ---
Disabled | No
This cop checks for missing documentation comment for public methods.
It can optionally be configured to also require documentation for
non-public methods.
### Example
```ruby
# bad
class Foo
def bar
puts baz
end
end
module Foo
def bar
puts baz
end
end
def foo.bar
puts baz
end
# good
class Foo
# Documentation
def bar
puts baz
end
end
module Foo
# Documentation
def bar
puts baz
end
end
# Documenation
def foo.bar
puts baz
end
```
### Important attributes
Attribute | Value
--- | ---
Exclude | spec/\*\*/\*, test/\*\*/\*
RequireForNonPublicMethods | false
## Style/DotPosition
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks the . position in multi-line method calls.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | leading
SupportedStyles | leading, trailing
### References
* [https://github.com/bbatsov/ruby-style-guide#consistent-multi-line-chains](https://github.com/bbatsov/ruby-style-guide#consistent-multi-line-chains)
## Style/DoubleNegation
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for uses of double negation (!!) to convert something
to a boolean value. As this is both cryptic and usually redundant, it
should be avoided.
Please, note that when something is a boolean value
!!something and !something.nil? are not the same thing.
As you're unlikely to write code that can accept values of any type
this is rarely a problem in practice.
### Example
```ruby
# bad
!!something
# good
!something.nil?
```
### References
* [https://github.com/bbatsov/ruby-style-guide#no-bang-bang](https://github.com/bbatsov/ruby-style-guide#no-bang-bang)
## Style/EachForSimpleLoop
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for loops which iterate a constant number of times,
using a Range literal and `#each`. This can be done more readably using
`Integer#times`.
This check only applies if the block takes no parameters.
### Example
```ruby
# bad
(1..5).each { }
# good
5.times { }
```
```ruby
# bad
(0...10).each {}
# good
10.times {}
```
## Style/EachWithObject
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop looks for inject / reduce calls where the passed in object is
returned at the end and so could be replaced by each_with_object without
the need to return the object at the end.
However, we can't replace with each_with_object if the accumulator
parameter is assigned to within the block.
### Example
```ruby
# bad
[1, 2].inject({}) { |a, e| a[e] = e; a }
# good
[1, 2].each_with_object({}) { |e, a| a[e] = e }
```
## Style/ElseAlignment
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cops checks the alignment of else keywords. Normally they should
be aligned with an if/unless/while/until/begin/def keyword, but there
are special cases when they should follow the same rules as the
alignment of end.
## Style/EmptyCaseCondition
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for case statements with an empty condition.
### Example
```ruby
# bad:
case
when x == 0
puts 'x is 0'
when y == 0
puts 'y is 0'
else
puts 'neither is 0'
end
# good:
if x == 0
puts 'x is 0'
elsif y == 0
puts 'y is 0'
else
puts 'neither is 0'
end
# good: (the case condition node is not empty)
case n
when 0
puts 'zero'
when 1
puts 'one'
else
puts 'more'
end
```
## Style/EmptyElse
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks for empty else-clauses, possibly including comments and/or an
explicit `nil` depending on the EnforcedStyle.
SupportedStyles:
### Example
```ruby
# good for all styles
if condition
statement
else
statement
end
# good for all styles
if condition
statement
end
```
```ruby
# empty - warn only on empty else
# bad
if condition
statement
else
end
# good
if condition
statement
else
nil
end
```
```ruby
# nil - warn on else with nil in it
# bad
if condition
statement
else
nil
end
# good
if condition
statement
else
end
```
```ruby
# both - warn on empty else and else with nil in it
# bad
if condition
statement
else
nil
end
# bad
if condition
statement
else
end
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | both
SupportedStyles | empty, nil, both
## Style/EmptyLineAfterMagicComment
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks for a newline after the final magic comment.
### Example
```ruby
# good
# frozen_string_literal: true
# Some documentation for Person
class Person
# Some code
end
# bad
# frozen_string_literal: true
# Some documentation for Person
class Person
# Some code
end
```
### References
* [https://github.com/bbatsov/ruby-style-guide#separate-magic-comments-from-code](https://github.com/bbatsov/ruby-style-guide#separate-magic-comments-from-code)
## Style/EmptyLineBetweenDefs
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks whether method definitions are
separated by one empty line.
`NumberOfEmptyLines` can be and integer (e.g. 1 by default) or
an array (e.g. [1, 2]) to specificy a minimum and a maximum of
empty lines.
`AllowAdjacentOneLineDefs` can be used to configure is adjacent
one line methods definitions are an offense
### Example
```ruby
# bad
def a
end
def b
end
```
```ruby
# good
def a
end
def b
end
```
### Important attributes
Attribute | Value
--- | ---
AllowAdjacentOneLineDefs | false
NumberOfEmptyLines | 1
### References
* [https://github.com/bbatsov/ruby-style-guide#empty-lines-between-methods](https://github.com/bbatsov/ruby-style-guide#empty-lines-between-methods)
## Style/EmptyLines
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cops checks for two or more consecutive blank lines.
### References
* [https://github.com/bbatsov/ruby-style-guide#two-or-more-empty-lines](https://github.com/bbatsov/ruby-style-guide#two-or-more-empty-lines)
## Style/EmptyLinesAroundAccessModifier
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Access modifiers should be surrounded by blank lines.
### References
* [https://github.com/bbatsov/ruby-style-guide#empty-lines-around-access-modifier](https://github.com/bbatsov/ruby-style-guide#empty-lines-around-access-modifier)
## Style/EmptyLinesAroundBeginBody
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cops checks if empty lines exist around the bodies of begin-end
blocks.
### Example
```ruby
# good
begin
...
end
# bad
begin
...
end
```
### References
* [https://github.com/bbatsov/ruby-style-guide#empty-lines-around-bodies](https://github.com/bbatsov/ruby-style-guide#empty-lines-around-bodies)
## Style/EmptyLinesAroundBlockBody
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cops checks if empty lines around the bodies of blocks match
the configuration.
### Example
```ruby
# EnforcedStyle: empty_lines
# good
foo do |bar|
...
end
# EnforcedStyle: no_empty_lines
# good
foo do |bar|
...
end
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | no_empty_lines
SupportedStyles | empty_lines, no_empty_lines
### References
* [https://github.com/bbatsov/ruby-style-guide#empty-lines-around-bodies](https://github.com/bbatsov/ruby-style-guide#empty-lines-around-bodies)
## Style/EmptyLinesAroundClassBody
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cops checks if empty lines around the bodies of classes match
the configuration.
### Example
```ruby
EnforcedStyle: empty_lines
# good
class Foo
def bar
...
end
end
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | no_empty_lines
SupportedStyles | empty_lines, empty_lines_except_namespace, empty_lines_special, no_empty_lines
### References
* [https://github.com/bbatsov/ruby-style-guide#empty-lines-around-bodies](https://github.com/bbatsov/ruby-style-guide#empty-lines-around-bodies)
## Style/EmptyLinesAroundExceptionHandlingKeywords
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cops checks if empty lines exist around the bodies of `begin`
sections. This cop doesn't check empty lines at `begin` body
beginning/end and around method definition body.
`Style/EmptyLinesAroundBeginBody` or `Style/EmptyLinesAroundMethodBody`
can be used for this purpose.
### Example
```ruby
# good
begin
do_something
rescue
do_something2
else
do_something3
ensure
do_something4
end
# good
def foo
do_something
rescue
do_something2
end
# bad
begin
do_something
rescue
do_something2
else
do_something3
ensure
do_something4
end
# bad
def foo
do_something
rescue
do_something2
end
```
### References
* [https://github.com/bbatsov/ruby-style-guide#empty-lines-around-bodies](https://github.com/bbatsov/ruby-style-guide#empty-lines-around-bodies)
## Style/EmptyLinesAroundMethodBody
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cops checks if empty lines exist around the bodies of methods.
### Example
```ruby
# good
def foo
...
end
# bad
def bar
...
end
```
### References
* [https://github.com/bbatsov/ruby-style-guide#empty-lines-around-bodies](https://github.com/bbatsov/ruby-style-guide#empty-lines-around-bodies)
## Style/EmptyLinesAroundModuleBody
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cops checks if empty lines around the bodies of modules match
the configuration.
### Example
```ruby
EnforcedStyle: empty_lines
# good
module Foo
def bar
...
end
end
EnforcedStyle: no_empty_lines
# good
module Foo
def bar
...
end
end
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | no_empty_lines
SupportedStyles | empty_lines, empty_lines_except_namespace, empty_lines_special, no_empty_lines
### References
* [https://github.com/bbatsov/ruby-style-guide#empty-lines-around-bodies](https://github.com/bbatsov/ruby-style-guide#empty-lines-around-bodies)
## Style/EmptyLiteral
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for the use of a method, the result of which
would be a literal, like an empty array, hash or string.
### References
* [https://github.com/bbatsov/ruby-style-guide#literal-array-hash](https://github.com/bbatsov/ruby-style-guide#literal-array-hash)
## Style/EmptyMethod
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for the formatting of empty method definitions.
By default it enforces empty method definitions to go on a single
line (compact style), but it can be configured to enforce the `end`
to go on its own line (expanded style.)
Note: A method definition is not considered empty if it contains
comments.
### Example
```ruby
EnforcedStyle: compact (default)
# bad
def foo(bar)
end
def self.foo(bar)
end
# good
def foo(bar); end
def foo(bar)
# baz
end
def self.foo(bar); end
EnforcedStyle: expanded
# bad
def foo(bar); end
def self.foo(bar); end
# good
def foo(bar)
end
def self.foo(bar)
end
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | compact
SupportedStyles | compact, expanded
### References
* [https://github.com/bbatsov/ruby-style-guide#no-single-line-methods](https://github.com/bbatsov/ruby-style-guide#no-single-line-methods)
## Style/Encoding
Enabled by default | Supports autocorrection
--- | ---
Disabled | Yes
This cop checks whether the source file has a utf-8 encoding
comment or not.
Setting this check to "always" and "when_needed" makes sense only
for code that should support Ruby 1.9, since in 2.0+ utf-8 is the
default source file encoding. There are three styles:
when_needed - only enforce an encoding comment if there are non ASCII
characters, otherwise report an offense
always - enforce encoding comment in all files
never - enforce no encoding comment in all files
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | never
SupportedStyles | when_needed, always, never
AutoCorrectEncodingComment | # encoding: utf-8
### References
* [https://github.com/bbatsov/ruby-style-guide#utf-8](https://github.com/bbatsov/ruby-style-guide#utf-8)
## Style/EndBlock
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for END blocks.
### References
* [https://github.com/bbatsov/ruby-style-guide#no-END-blocks](https://github.com/bbatsov/ruby-style-guide#no-END-blocks)
## Style/EndOfLine
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for Windows-style line endings in the source code.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | native
SupportedStyles | native, lf, crlf
### References
* [https://github.com/bbatsov/ruby-style-guide#crlf](https://github.com/bbatsov/ruby-style-guide#crlf)
## Style/EvenOdd
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for places where Integer#even? or Integer#odd?
should have been used.
### Example
```ruby
# bad
if x % 2 == 0
# good
if x.even?
```
### References
* [https://github.com/bbatsov/ruby-style-guide#predicate-methods](https://github.com/bbatsov/ruby-style-guide#predicate-methods)
## Style/ExtraSpacing
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for extra/unnecessary whitespace.
### Example
```ruby
# good if AllowForAlignment is true
name = "RuboCop"
# Some comment and an empty line
website += "/bbatsov/rubocop" unless cond
puts "rubocop" if debug
# bad for any configuration
set_app("RuboCop")
website = "https://github.com/bbatsov/rubocop"
```
### Important attributes
Attribute | Value
--- | ---
AllowForAlignment | true
ForceEqualSignAlignment | false
## Style/FileName
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop makes sure that Ruby source files have snake_case
names. Ruby scripts (i.e. source files with a shebang in the
first line) are ignored.
### Important attributes
Attribute | Value
--- | ---
Exclude |
ExpectMatchingDefinition | false
Regex |
IgnoreExecutableScripts | true
AllowedAcronyms | CLI, DSL, ACL, API, ASCII, CPU, CSS, DNS, EOF, GUID, HTML, HTTP, HTTPS, ID, IP, JSON, LHS, QPS, RAM, RHS, RPC, SLA, SMTP, SQL, SSH, TCP, TLS, TTL, UDP, UI, UID, UUID, URI, URL, UTF8, VM, XML, XMPP, XSRF, XSS
### References
* [https://github.com/bbatsov/ruby-style-guide#snake-case-files](https://github.com/bbatsov/ruby-style-guide#snake-case-files)
## Style/FirstArrayElementLineBreak
Enabled by default | Supports autocorrection
--- | ---
Disabled | Yes
This cop checks for a line break before the first element in a
multi-line array.
### Example
```ruby
# bad
[ :a,
:b]
# good
[
:a,
:b]
```
## Style/FirstHashElementLineBreak
Enabled by default | Supports autocorrection
--- | ---
Disabled | Yes
This cop checks for a line break before the first element in a
multi-line hash.
### Example
```ruby
# bad
{ a: 1,
b: 2}
# good
{
a: 1,
b: 2 }
```
## Style/FirstMethodArgumentLineBreak
Enabled by default | Supports autocorrection
--- | ---
Disabled | Yes
This cop checks for a line break before the first argument in a
multi-line method call.
### Example
```ruby
# bad
method(foo, bar,
baz)
# good
method(
foo, bar,
baz)
# ignored
method foo, bar,
baz
```
## Style/FirstMethodParameterLineBreak
Enabled by default | Supports autocorrection
--- | ---
Disabled | Yes
This cop checks for a line break before the first parameter in a
multi-line method parameter definition.
### Example
```ruby
# bad
def method(foo, bar,
baz)
do_something
end
# good
def method(
foo, bar,
baz)
do_something
end
# ignored
def method foo,
bar
do_something
end
```
## Style/FirstParameterIndentation
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks the indentation of the first parameter in a method call.
Parameters after the first one are checked by Style/AlignParameters, not
by this cop.
### Example
```ruby
# bad
some_method(
first_param,
second_param)
# good
some_method(
first_param,
second_param)
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | special_for_inner_method_call_in_parentheses
SupportedStyles | consistent, special_for_inner_method_call, special_for_inner_method_call_in_parentheses
IndentationWidth |
## Style/FlipFlop
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop looks for uses of flip flop operator
### References
* [https://github.com/bbatsov/ruby-style-guide#no-flip-flops](https://github.com/bbatsov/ruby-style-guide#no-flip-flops)
## Style/For
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop looks for uses of the *for* keyword, or *each* method. The
preferred alternative is set in the EnforcedStyle configuration
parameter. An *each* call with a block on a single line is always
allowed, however.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | each
SupportedStyles | for, each
### References
* [https://github.com/bbatsov/ruby-style-guide#no-for-loops](https://github.com/bbatsov/ruby-style-guide#no-for-loops)
## Style/FormatString
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop enforces the use of a single string formatting utility.
Valid options include Kernel#format, Kernel#sprintf and String#%.
The detection of String#% cannot be implemented in a reliable
manner for all cases, so only two scenarios are considered -
if the first argument is a string literal and if the second
argument is an array literal.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | format
SupportedStyles | format, sprintf, percent
### References
* [https://github.com/bbatsov/ruby-style-guide#sprintf](https://github.com/bbatsov/ruby-style-guide#sprintf)
## Style/FrozenStringLiteralComment
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop is designed to help upgrade to Ruby 3.0. It will add the
comment `# frozen_string_literal: true` to the top of files to
enable frozen string literals. Frozen string literals will be default
in Ruby 3.0. The comment will be added below a shebang and encoding
comment. The frozen string literal comment is only valid in Ruby 2.3+.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | when_needed
SupportedStyles | when_needed, always, never
## Style/GlobalVars
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cops looks for uses of global variables.
It does not report offenses for built-in global variables.
Built-in global variables are allowed by default. Additionally
users can allow additional variables via the AllowedVariables option.
Note that backreferences like $1, $2, etc are not global variables.
### Important attributes
Attribute | Value
--- | ---
AllowedVariables |
### References
* [https://github.com/bbatsov/ruby-style-guide#instance-vars](https://github.com/bbatsov/ruby-style-guide#instance-vars)
* [http://www.zenspider.com/Languages/Ruby/QuickRef.html](http://www.zenspider.com/Languages/Ruby/QuickRef.html)
## Style/GuardClause
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
Use a guard clause instead of wrapping the code inside a conditional
expression
### Example
```ruby
# bad
def test
if something
work
end
end
# good
def test
return unless something
work
end
# also good
def test
work if something
end
# bad
if something
raise 'exception'
else
ok
end
# good
raise 'exception' if something
ok
```
### Important attributes
Attribute | Value
--- | ---
MinBodyLength | 1
### References
* [https://github.com/bbatsov/ruby-style-guide#no-nested-conditionals](https://github.com/bbatsov/ruby-style-guide#no-nested-conditionals)
## Style/HashSyntax
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks hash literal syntax.
It can enforce either the use of the class hash rocket syntax or
the use of the newer Ruby 1.9 syntax (when applicable).
A separate offense is registered for each problematic pair.
The supported styles are:
* ruby19 - forces use of the 1.9 syntax (e.g. {a: 1}) when hashes have
all symbols for keys
* hash_rockets - forces use of hash rockets for all hashes
* no_mixed_keys - simply checks for hashes with mixed syntaxes
* ruby19_no_mixed_keys - forces use of ruby 1.9 syntax and forbids mixed
syntax hashes
### Example
```ruby
"EnforcedStyle => 'ruby19'"
# good
{a: 2, b: 1}
{:c => 2, 'd' => 2} # acceptable since 'd' isn't a symbol
{d: 1, 'e' => 2} # technically not forbidden
# bad
{:a => 2}
{b: 1, :c => 2}
```
```ruby
"EnforcedStyle => 'hash_rockets'"
# good
{:a => 1, :b => 2}
# bad
{a: 1, b: 2}
{c: 1, 'd' => 5}
```
```ruby
"EnforcedStyle => 'no_mixed_keys'"
# good
{:a => 1, :b => 2}
{c: 1, d: 2}
# bad
{:a => 1, b: 2}
{c: 1, 'd' => 2}
```
```ruby
"EnforcedStyle => 'ruby19_no_mixed_keys'"
# good
{a: 1, b: 2}
{:c => 3, 'd' => 4}
# bad
{:a => 1, :b => 2}
{c: 2, 'd' => 3} # should just use hash rockets
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | ruby19
SupportedStyles | ruby19, hash_rockets, no_mixed_keys, ruby19_no_mixed_keys
UseHashRocketsWithSymbolValues | false
PreferHashRocketsForNonAlnumEndingSymbols | false
### References
* [https://github.com/bbatsov/ruby-style-guide#hash-literals](https://github.com/bbatsov/ruby-style-guide#hash-literals)
## Style/IdenticalConditionalBranches
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for identical lines at the beginning or end of
each branch of a conditional statement.
### Example
```ruby
# bad
if condition
do_x
do_z
else
do_y
do_z
end
# good
if condition
do_x
else
do_y
end
do_z
# bad
if condition
do_z
do_x
else
do_z
do_y
end
# good
do_z
if condition
do_x
else
do_y
end
# bad
switch foo
when 1
do_x
when 2
do_x
else
do_x
end
# good
switch foo
when 1
do_x
do_y
when 2
# nothing
else
do_x
do_z
end
```
## Style/IfInsideElse
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
If the `else` branch of a conditional consists solely of an `if` node,
it can be combined with the `else` to become an `elsif`.
This helps to keep the nesting level from getting too deep.
### Example
```ruby
# good
if condition_a
action_a
elsif condition_b
action_b
else
action_c
end
# bad
if condition_a
action_a
else
if condition_b
action_b
else
action_c
end
end
```
## Style/IfUnlessModifier
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks for if and unless statements that would fit on one line
if written as a modifier if/unless.
The maximum line length is configurable.
### Important attributes
Attribute | Value
--- | ---
MaxLineLength | 80
### References
* [https://github.com/bbatsov/ruby-style-guide#if-as-a-modifier](https://github.com/bbatsov/ruby-style-guide#if-as-a-modifier)
## Style/IfUnlessModifierOfIfUnless
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
Checks for if and unless statements used as modifers of other if or
unless statements.
### Example
```ruby
# bad
tired? ? 'stop' : 'go faster' if running?
# bad
if tired?
"please stop"
else
"keep going"
end if running?
# good
if running?
tired? ? 'stop' : 'go faster'
end
```
## Style/IfWithSemicolon
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
Checks for uses of semicolon in if statements.
### References
* [https://github.com/bbatsov/ruby-style-guide#no-semicolon-ifs](https://github.com/bbatsov/ruby-style-guide#no-semicolon-ifs)
## Style/ImplicitRuntimeError
Enabled by default | Supports autocorrection
--- | ---
Disabled | No
This cop checks for `raise` or `fail` statements which do not specify an
explicit exception class. (This raises a `RuntimeError`. Some projects
might prefer to use exception classes which more precisely identify the
nature of the error.)
### Example
```ruby
# bad
raise 'Error message here'
# good
raise ArgumentError, 'Error message here'
```
## Style/IndentArray
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks the indentation of the first element in an array literal
where the opening bracket and the first element are on separate lines.
The other elements' indentations are handled by the AlignArray cop.
By default, array literals that are arguments in a method call with
parentheses, and where the opening square bracket of the array is on the
same line as the opening parenthesis of the method call, shall have
their first element indented one step (two spaces) more than the
position inside the opening parenthesis.
Other array literals shall have their first element indented one step
more than the start of the line where the opening square bracket is.
This default style is called 'special_inside_parentheses'. Alternative
styles are 'consistent' and 'align_brackets'. Here are examples:
# special_inside_parentheses
array = [
:value
]
but_in_a_method_call([
:its_like_this
])
# consistent
array = [
:value
]
and_in_a_method_call([
:no_difference
])
# align_brackets
and_now_for_something = [
:completely_different
]
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | special_inside_parentheses
SupportedStyles | special_inside_parentheses, consistent, align_brackets
IndentationWidth |
## Style/IndentAssignment
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks the indentation of the first line of the
right-hand-side of a multi-line assignment.
The indentation of the remaining lines can be corrected with
other cops such as `IndentationConsistency` and `EndAlignment`.
### Example
```ruby
# bad
value =
if foo
'bar'
end
# good
value =
if foo
'bar'
end
```
### Important attributes
Attribute | Value
--- | ---
IndentationWidth |
## Style/IndentHash
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cops checks the indentation of the first key in a hash literal
where the opening brace and the first key are on separate lines. The
other keys' indentations are handled by the AlignHash cop.
By default, Hash literals that are arguments in a method call with
parentheses, and where the opening curly brace of the hash is on the
same line as the opening parenthesis of the method call, shall have
their first key indented one step (two spaces) more than the position
inside the opening parenthesis.
Other hash literals shall have their first key indented one step more
than the start of the line where the opening curly brace is.
This default style is called 'special_inside_parentheses'. Alternative
styles are 'consistent' and 'align_braces'. Here are examples:
# special_inside_parentheses
hash = {
key: :value
}
but_in_a_method_call({
its_like: :this
})
# consistent
hash = {
key: :value
}
and_in_a_method_call({
no: :difference
})
# align_braces
and_now_for_something = {
completely: :different
}
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | special_inside_parentheses
SupportedStyles | special_inside_parentheses, consistent, align_braces
IndentationWidth |
## Style/IndentHeredoc
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cops checks the indentation of the here document bodies. The bodies
are indented one step.
In Ruby 2.3 or newer, squiggly heredocs (`<<~`) should be used. If you
use the older rubies, you should introduce some library to your project
(e.g. ActiveSupport, Powerpack or Unindent).
### Example
```ruby
# bad
<<-END
something
END
# good
# When EnforcedStyle is squiggly, bad code is auto-corrected to the
# following code.
<<~END
something
END
# good
# When EnforcedStyle is active_support, bad code is auto-corrected to
# the following code.
<<-END.strip_heredoc
something
END
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | auto_detection
SupportedStyles | auto_detection, squiggly, active_support, powerpack, unindent
### References
* [https://github.com/bbatsov/ruby-style-guide#squiggly-heredocs](https://github.com/bbatsov/ruby-style-guide#squiggly-heredocs)
## Style/IndentationConsistency
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cops checks for inconsistent indentation.
### Example
```ruby
class A
def test
puts 'hello'
puts 'world'
end
end
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | normal
SupportedStyles | normal, rails
### References
* [https://github.com/bbatsov/ruby-style-guide#spaces-indentation](https://github.com/bbatsov/ruby-style-guide#spaces-indentation)
## Style/IndentationWidth
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cops checks for indentation that doesn't use the specified number
of spaces.
See also the IndentationConsistency cop which is the companion to this
one.
### Example
```ruby
# bad, Width: 2
class A
def test
puts 'hello'
end
end
# bad, Width: 2,
IgnoredPatterns:
- '^\s*module'
module A
class B
def test
puts 'hello'
end
end
end
# good, Width: 2
class A
def test
puts 'hello'
end
end
# good, Width: 2,
IgnoredPatterns:
- '^\s*module'
module A
class B
def test
puts 'hello'
end
end
end
```
### Important attributes
Attribute | Value
--- | ---
Width | 2
IgnoredPatterns |
### References
* [https://github.com/bbatsov/ruby-style-guide#spaces-indentation](https://github.com/bbatsov/ruby-style-guide#spaces-indentation)
## Style/InfiniteLoop
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Use `Kernel#loop` for infinite loops.
### Example
```ruby
# bad
while true
work
end
# good
loop do
work
end
```
### References
* [https://github.com/bbatsov/ruby-style-guide#infinite-loop](https://github.com/bbatsov/ruby-style-guide#infinite-loop)
## Style/InitialIndentation
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cops checks for indentation of the first non-blank non-comment
line in a file.
## Style/InlineComment
Enabled by default | Supports autocorrection
--- | ---
Disabled | No
This cop checks for trailing inline comments.
### Example
```ruby
# good
foo.each do |f|
# Standalone comment
f.bar
end
# bad
foo.each do |f|
f.bar # Trailing inline comment
end
```
## Style/InverseMethods
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop check for usages of not (`not` or `!`) called on a method
when an inverse of that method can be used instead.
Methods that can be inverted by a not (`not` or `!`) should be defined
in `InverseMethods`
Methods that are inverted by inverting the return
of the block that is passed to the method should be defined in
`InverseBlocks`
### Example
```ruby
# bad
!foo.none?
!foo.any? { |f| f.even? }
!foo.blank?
!(foo == bar)
foo.select { |f| !f.even? }
foo.reject { |f| f != 7 }
# good
foo.none?
foo.blank?
foo.any? { |f| f.even? }
foo != bar
foo == bar
```
### Important attributes
Attribute | Value
--- | ---
InverseMethods | {:any?=>:none?, :even?=>:odd?, :===>:!=, :=~=>:!~, :<=>:>=, :>=>:<=}
InverseBlocks | {:select=>:reject, :select!=>:reject!}
## Style/Lambda
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop (by default) checks for uses of the lambda literal syntax for
single line lambdas, and the method call syntax for multiline lambdas.
It is configurable to enforce one of the styles for both single line
and multiline lambdas as well.
### Example
```ruby
# EnforcedStyle: line_count_dependent (default)
# bad
f = lambda { |x| x }
f = ->(x) do
x
end
# good
f = ->(x) { x }
f = lambda do |x|
x
end
```
```ruby
# EnforcedStyle: lambda
# bad
f = ->(x) { x }
f = ->(x) do
x
end
# good
f = lambda { |x| x }
f = lambda do |x|
x
end
```
```ruby
# EnforcedStyle: literal
# bad
f = lambda { |x| x }
f = lambda do |x|
x
end
# good
f = ->(x) { x }
f = ->(x) do
x
end
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | line_count_dependent
SupportedStyles | line_count_dependent, lambda, literal
### References
* [https://github.com/bbatsov/ruby-style-guide#lambda-multi-line](https://github.com/bbatsov/ruby-style-guide#lambda-multi-line)
## Style/LambdaCall
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for use of the lambda.(args) syntax.
### Example
```ruby
# bad
lambda.(x, y)
# good
lambda.call(x, y)
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | call
SupportedStyles | call, braces
### References
* [https://github.com/bbatsov/ruby-style-guide#proc-call](https://github.com/bbatsov/ruby-style-guide#proc-call)
## Style/LeadingCommentSpace
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks whether comments have a leading space
after the # denoting the start of the comment. The
leading space is not required for some RDoc special syntax,
like #++, #--, #:nodoc, etc. Neither is it required for
=begin/=end comments.
### References
* [https://github.com/bbatsov/ruby-style-guide#hash-space](https://github.com/bbatsov/ruby-style-guide#hash-space)
## Style/LineEndConcatenation
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for string literal concatenation at
the end of a line.
### Example
```ruby
# bad
some_str = 'ala' +
'bala'
some_str = 'ala' <<
'bala'
# good
some_str = 'ala' \
'bala'
```
## Style/MethodCallWithArgsParentheses
Enabled by default | Supports autocorrection
--- | ---
Disabled | Yes
This cop checks presence of parentheses in method calls containing
parameters. By default, macro methods are ignored. Additional methods
can be added to the `IgnoredMethods` list.
### Example
```ruby
# bad
array.delete e
# good
array.delete(e)
# good
# Operators don't need parens
foo == bar
# good
# Setter methods don't need parens
foo.bar = baz
# okay with `puts` listed in `IgnoredMethods`
puts 'test'
# IgnoreMacros: true (default)
# good
class Foo
bar :baz
end
# IgnoreMacros: false
# bad
class Foo
bar :baz
end
```
### Important attributes
Attribute | Value
--- | ---
IgnoreMacros | true
IgnoredMethods |
### References
* [https://github.com/bbatsov/ruby-style-guide#method-invocation-parens](https://github.com/bbatsov/ruby-style-guide#method-invocation-parens)
## Style/MethodCallWithoutArgsParentheses
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for unwanted parentheses in parameterless method calls.
### Example
```ruby
# bad
object.some_method()
# good
object.some_method
```
### References
* [https://github.com/bbatsov/ruby-style-guide#method-invocation-parens](https://github.com/bbatsov/ruby-style-guide#method-invocation-parens)
## Style/MethodCalledOnDoEndBlock
Enabled by default | Supports autocorrection
--- | ---
Disabled | No
This cop checks for methods called on a do...end block. The point of
this check is that it's easy to miss the call tacked on to the block
when reading code.
### Example
```ruby
a do
b
end.c
```
### References
* [https://github.com/bbatsov/ruby-style-guide#single-line-blocks](https://github.com/bbatsov/ruby-style-guide#single-line-blocks)
## Style/MethodDefParentheses
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cops checks for parentheses around the arguments in method
definitions. Both instance and class/singleton methods are checked.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | require_parentheses
SupportedStyles | require_parentheses, require_no_parentheses, require_no_parentheses_except_multiline
### References
* [https://github.com/bbatsov/ruby-style-guide#method-parens](https://github.com/bbatsov/ruby-style-guide#method-parens)
## Style/MethodMissing
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for the presence of `method_missing` without also
defining `respond_to_missing?` and falling back on `super`.
### Example
```ruby
#bad
def method_missing(...)
...
end
#good
def respond_to_missing?(...)
...
end
def method_missing(...)
...
super
end
```
### References
* [https://github.com/bbatsov/ruby-style-guide#no-method-missing](https://github.com/bbatsov/ruby-style-guide#no-method-missing)
## Style/MethodName
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop makes sure that all methods use the configured style,
snake_case or camelCase, for their names. Some special arrangements
have to be made for operator methods.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | snake_case
SupportedStyles | snake_case, camelCase
### References
* [https://github.com/bbatsov/ruby-style-guide#snake-case-symbols-methods-vars](https://github.com/bbatsov/ruby-style-guide#snake-case-symbols-methods-vars)
## Style/MissingElse
Enabled by default | Supports autocorrection
--- | ---
Disabled | No
Checks for `if` expressions that do not have an `else` branch.
SupportedStyles
if
case
### Example
```ruby
# bad
if condition
statement
end
```
```ruby
# bad
case var
when condition
statement
end
```
```ruby
# good
if condition
statement
else
# the content of the else branch will be determined by Style/EmptyElse
end
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | both
SupportedStyles | if, case, both
## Style/MixinGrouping
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for grouping of mixins in `class` and `module` bodies.
By default it enforces mixins to be placed in separate declarations,
but it can be configured to enforce grouping them in one declaration.
### Example
```ruby
EnforcedStyle: separated (default)
# bad
class Foo
include Bar, Qox
end
# good
class Foo
include Qox
include Bar
end
EnforcedStyle: grouped
# bad
class Foo
extend Bar
extend Qox
end
# good
class Foo
extend Qox, Bar
end
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | separated
SupportedStyles | separated, grouped
### References
* [https://github.com/bbatsov/ruby-style-guide#mixin-grouping](https://github.com/bbatsov/ruby-style-guide#mixin-grouping)
## Style/ModuleFunction
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cops checks for use of `extend self` or `module_function` in a
module.
Supported styles are: module_function, extend_self.
These offenses are not auto-corrected since there are different
implications to each approach.
### Example
```ruby
# Good if EnforcedStyle is module_function
module Test
module_function
...
end
# Good if EnforcedStyle is extend_self
module Test
extend self
...
end
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | module_function
SupportedStyles | module_function, extend_self
### References
* [https://github.com/bbatsov/ruby-style-guide#module-function](https://github.com/bbatsov/ruby-style-guide#module-function)
## Style/MultilineArrayBraceLayout
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks that the closing brace in an array literal is either
on the same line as the last array element, or a new line.
When using the `symmetrical` (default) style:
If an array's opening brace is on the same line as the first element
of the array, then the closing brace should be on the same line as
the last element of the array.
If an array's opening brace is on the line above the first element
of the array, then the closing brace should be on the line below
the last element of the array.
When using the `new_line` style:
The closing brace of a multi-line array literal must be on the line
after the last element of the array.
When using the `same_line` style:
The closing brace of a multi-line array literal must be on the same
line as the last element of the array.
### Example
```ruby
# symmetrical: bad
# new_line: good
# same_line: bad
[ :a,
:b
]
# symmetrical: bad
# new_line: bad
# same_line: good
[
:a,
:b ]
# symmetrical: good
# new_line: bad
# same_line: good
[ :a,
:b ]
# symmetrical: good
# new_line: good
# same_line: bad
[
:a,
:b
]
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | symmetrical
SupportedStyles | symmetrical, new_line, same_line
## Style/MultilineAssignmentLayout
Enabled by default | Supports autocorrection
--- | ---
Disabled | Yes
This cop checks whether the multiline assignments have a newline
after the assignment operator.
### Example
```ruby
# bad (with EnforcedStyle set to new_line)
foo = if expression
'bar'
end
# good (with EnforcedStyle set to same_line)
foo = if expression
'bar'
end
# good (with EnforcedStyle set to new_line)
foo =
if expression
'bar'
end
# good (with EnforcedStyle set to new_line)
foo =
begin
compute
rescue => e
nil
end
```
### Important attributes
Attribute | Value
--- | ---
SupportedTypes | block, case, class, if, kwbegin, module
EnforcedStyle | new_line
SupportedStyles | same_line, new_line
### References
* [https://github.com/bbatsov/ruby-style-guide#indent-conditional-assignment](https://github.com/bbatsov/ruby-style-guide#indent-conditional-assignment)
## Style/MultilineBlockChain
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for chaining of a block after another block that spans
multiple lines.
### Example
```ruby
Thread.list.find_all do |t|
t.alive?
end.map do |t|
t.object_id
end
```
### References
* [https://github.com/bbatsov/ruby-style-guide#single-line-blocks](https://github.com/bbatsov/ruby-style-guide#single-line-blocks)
## Style/MultilineBlockLayout
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks whether the multiline do end blocks have a newline
after the start of the block. Additionally, it checks whether the block
arguments, if any, are on the same line as the start of the block.
### Example
```ruby
# bad
blah do |i| foo(i)
bar(i)
end
# bad
blah do
|i| foo(i)
bar(i)
end
# good
blah do |i|
foo(i)
bar(i)
end
# bad
blah { |i| foo(i)
bar(i)
}
# good
blah { |i|
foo(i)
bar(i)
}
```
## Style/MultilineHashBraceLayout
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks that the closing brace in a hash literal is either
on the same line as the last hash element, or a new line.
When using the `symmetrical` (default) style:
If a hash's opening brace is on the same line as the first element
of the hash, then the closing brace should be on the same line as
the last element of the hash.
If a hash's opening brace is on the line above the first element
of the hash, then the closing brace should be on the line below
the last element of the hash.
When using the `new_line` style:
The closing brace of a multi-line hash literal must be on the line
after the last element of the hash.
When using the `same_line` style:
The closing brace of a multi-line hash literal must be on the same
line as the last element of the hash.
### Example
```ruby
# symmetrical: bad
# new_line: good
# same_line: bad
{ a: 1,
b: 2
}
# symmetrical: bad
# new_line: bad
# same_line: good
{
a: 1,
b: 2 }
# symmetrical: good
# new_line: bad
# same_line: good
{ a: 1,
b: 2 }
# symmetrical: good
# new_line: good
# same_line: bad
{
a: 1,
b: 2
}
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | symmetrical
SupportedStyles | symmetrical, new_line, same_line
## Style/MultilineIfModifier
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks for uses of if/unless modifiers with multiple-lines bodies.
### Example
```ruby
# bad
{
result: 'this should not happen'
} unless cond
# good
{ result: 'ok' } if cond
```
### References
* [https://github.com/bbatsov/ruby-style-guide#no-multiline-if-modifiers](https://github.com/bbatsov/ruby-style-guide#no-multiline-if-modifiers)
## Style/MultilineIfThen
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks for uses of the `then` keyword in multi-line if statements.
### Example
```ruby
if cond then
end
```
```ruby
if cond then a
elsif cond then b
end
```
### References
* [https://github.com/bbatsov/ruby-style-guide#no-then](https://github.com/bbatsov/ruby-style-guide#no-then)
## Style/MultilineMemoization
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks expressions wrapping styles for multiline memoization.
### Example
```ruby
# EnforcedStyle: keyword (default)
# bad
foo ||= (
bar
baz
)
# good
foo ||= begin
bar
baz
end
```
```ruby
# EnforcedStyle: braces
# bad
foo ||= begin
bar
baz
end
# good
foo ||= (
bar
baz
)
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | keyword
SupportedStyles | keyword, braces
## Style/MultilineMethodCallBraceLayout
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks that the closing brace in a method call is either
on the same line as the last method argument, or a new line.
When using the `symmetrical` (default) style:
If a method call's opening brace is on the same line as the first
argument of the call, then the closing brace should be on the same
line as the last argument of the call.
If an method call's opening brace is on the line above the first
argument of the call, then the closing brace should be on the line
below the last argument of the call.
When using the `new_line` style:
The closing brace of a multi-line method call must be on the line
after the last argument of the call.
When using the `same_line` style:
The closing brace of a multi-line method call must be on the same
line as the last argument of the call.
### Example
```ruby
# symmetrical: bad
# new_line: good
# same_line: bad
foo(a,
b
)
# symmetrical: bad
# new_line: bad
# same_line: good
foo(
a,
b)
# symmetrical: good
# new_line: bad
# same_line: good
foo(a,
b)
# symmetrical: good
# new_line: good
# same_line: bad
foo(
a,
b
)
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | symmetrical
SupportedStyles | symmetrical, new_line, same_line
## Style/MultilineMethodCallIndentation
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks the indentation of the method name part in method calls
that span more than one line.
### Example
```ruby
# bad
while myvariable
.b
# do something
end
# good, EnforcedStyle: aligned
while myvariable
.b
# do something
end
# good, EnforcedStyle: aligned
Thing.a
.b
.c
# good, EnforcedStyle: indented,
IndentationWidth: 2
while myvariable
.b
# do something
end
# good, EnforcedStyle: indented_relative_to_receiver,
IndentationWidth: 2
while myvariable
.a
.b
# do something
end
# good, EnforcedStyle: indented_relative_to_receiver,
IndentationWidth: 2
myvariable = Thing
.a
.b
.c
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | aligned
SupportedStyles | aligned, indented, indented_relative_to_receiver
IndentationWidth |
## Style/MultilineMethodDefinitionBraceLayout
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks that the closing brace in a method definition is either
on the same line as the last method parameter, or a new line.
When using the `symmetrical` (default) style:
If a method definition's opening brace is on the same line as the
first parameter of the definition, then the closing brace should be
on the same line as the last parameter of the definition.
If an method definition's opening brace is on the line above the first
parameter of the definition, then the closing brace should be on the
line below the last parameter of the definition.
When using the `new_line` style:
The closing brace of a multi-line method definition must be on the line
after the last parameter of the definition.
When using the `same_line` style:
The closing brace of a multi-line method definition must be on the same
line as the last parameter of the definition.
### Example
```ruby
# symmetrical: bad
# new_line: good
# same_line: bad
def foo(a,
b
)
# symmetrical: bad
# new_line: bad
# same_line: good
def foo(
a,
b)
# symmetrical: good
# new_line: bad
# same_line: good
def foo(a,
b)
# symmetrical: good
# new_line: good
# same_line: bad
def foo(
a,
b
)
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | symmetrical
SupportedStyles | symmetrical, new_line, same_line
## Style/MultilineOperationIndentation
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks the indentation of the right hand side operand in
binary operations that span more than one line.
### Example
```ruby
# bad
if a +
b
something
end
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | aligned
SupportedStyles | aligned, indented
IndentationWidth |
## Style/MultilineTernaryOperator
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for multi-line ternary op expressions.
### References
* [https://github.com/bbatsov/ruby-style-guide#no-multiline-ternary](https://github.com/bbatsov/ruby-style-guide#no-multiline-ternary)
## Style/MutableConstant
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks whether some constant value isn't a
mutable literal (e.g. array or hash).
### Example
```ruby
# bad
CONST = [1, 2, 3]
# good
CONST = [1, 2, 3].freeze
```
## Style/NegatedIf
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks for uses of if with a negated condition. Only ifs
without else are considered. There are three different styles:
- both
- prefix
- postfix
### Example
```ruby
# EnforcedStyle: both
# enforces `unless` for `prefix` and `postfix` conditionals
# good
unless foo
bar
end
# bad
if !foo
bar
end
# good
bar unless foo
# bad
bar if !foo
```
```ruby
# EnforcedStyle: prefix
# enforces `unless` for just `prefix` conditionals
# good
unless foo
bar
end
# bad
if !foo
bar
end
# good
bar if !foo
```
```ruby
# EnforcedStyle: postfix
# enforces `unless` for just `postfix` conditionals
# good
bar unless foo
# bad
bar if !foo
# good
if !foo
bar
end
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | both
SupportedStyles | both, prefix, postfix
### References
* [https://github.com/bbatsov/ruby-style-guide#unless-for-negatives](https://github.com/bbatsov/ruby-style-guide#unless-for-negatives)
## Style/NegatedWhile
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks for uses of while with a negated condition.
### References
* [https://github.com/bbatsov/ruby-style-guide#until-for-negatives](https://github.com/bbatsov/ruby-style-guide#until-for-negatives)
## Style/NestedModifier
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for nested use of if, unless, while and until in their
modifier form.
### Example
```ruby
# bad
something if a if b
# good
something if b && a
```
### References
* [https://github.com/bbatsov/ruby-style-guide#no-nested-modifiers](https://github.com/bbatsov/ruby-style-guide#no-nested-modifiers)
## Style/NestedParenthesizedCalls
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for unparenthesized method calls in the argument list
of a parenthesized method call.
### Example
```ruby
# good
method1(method2(arg), method3(arg))
# bad
method1(method2 arg, method3, arg)
```
## Style/NestedTernaryOperator
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for nested ternary op expressions.
### References
* [https://github.com/bbatsov/ruby-style-guide#no-nested-ternary](https://github.com/bbatsov/ruby-style-guide#no-nested-ternary)
## Style/Next
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Use `next` to skip iteration instead of a condition at the end.
### Example
```ruby
# bad
[1, 2].each do |a|
if a == 1 do
puts a
end
end
# good
[1, 2].each do |a|
next unless a == 1
puts a
end
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | skip_modifier_ifs
MinBodyLength | 3
SupportedStyles | skip_modifier_ifs, always
### References
* [https://github.com/bbatsov/ruby-style-guide#no-nested-conditionals](https://github.com/bbatsov/ruby-style-guide#no-nested-conditionals)
## Style/NilComparison
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for comparison of something with nil using ==.
### Example
```ruby
# bad
if x == nil
# good
if x.nil?
```
### References
* [https://github.com/bbatsov/ruby-style-guide#predicate-methods](https://github.com/bbatsov/ruby-style-guide#predicate-methods)
## Style/NonNilCheck
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for non-nil checks, which are usually redundant.
Non-nil checks are allowed if they are the final nodes of predicate.
# good
def signed_in?
!current_user.nil?
end
### Example
```ruby
# bad
if x != nil
# good (when not allowing semantic changes)
# bad (when allowing semantic changes)
if !x.nil?
# good (when allowing semantic changes)
if x
```
### Important attributes
Attribute | Value
--- | ---
IncludeSemanticChanges | false
### References
* [https://github.com/bbatsov/ruby-style-guide#no-non-nil-checks](https://github.com/bbatsov/ruby-style-guide#no-non-nil-checks)
## Style/Not
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for uses if the keyword *not* instead of !.
### References
* [https://github.com/bbatsov/ruby-style-guide#bang-not-not](https://github.com/bbatsov/ruby-style-guide#bang-not-not)
## Style/NumericLiteralPrefix
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for octal, hex, binary and decimal literals using
uppercase prefixes and corrects them to lowercase prefix
or no prefix (in case of decimals).
eg. for octal use `0o` instead of `0` or `0O`.
Can be configured to use `0` only for octal literals using
`EnforcedOctalStyle` => `zero_only`
### Important attributes
Attribute | Value
--- | ---
EnforcedOctalStyle | zero_with_o
SupportedOctalStyles | zero_with_o, zero_only
### References
* [https://github.com/bbatsov/ruby-style-guide#numeric-literal-prefixes](https://github.com/bbatsov/ruby-style-guide#numeric-literal-prefixes)
## Style/NumericLiterals
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for big numeric literals without _ between groups
of digits in them.
### Example
```ruby
# bad
1000000
1_00_000
1_0000
# good
1_000_000
1000
# good unless Strict is set
10_000_00 # typical representation of $10,000 in cents
```
### Important attributes
Attribute | Value
--- | ---
MinDigits | 5
Strict | false
### References
* [https://github.com/bbatsov/ruby-style-guide#underscores-in-numerics](https://github.com/bbatsov/ruby-style-guide#underscores-in-numerics)
## Style/NumericPredicate
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for usage of comparison operators (`==`,
`>`, `<`) to test numbers as zero, positive, or negative.
These can be replaced by their respective predicate methods.
The cop can also be configured to do the reverse.
The cop disregards `nonzero?` as it its value is truthy or falsey,
but not `true` and `false`, and thus not always interchangeable with
`!= 0`.
### Example
```ruby
# EnforcedStyle: predicate (default)
# bad
foo == 0
0 > foo
bar.baz > 0
# good
foo.zero?
foo.negative?
bar.baz.positive?
```
```ruby
# EnforcedStyle: comparison
# bad
foo.zero?
foo.negative?
bar.baz.positive?
# good
foo == 0
0 > foo
bar.baz > 0
```
### Important attributes
Attribute | Value
--- | ---
AutoCorrect | false
EnforcedStyle | predicate
SupportedStyles | predicate, comparison
Exclude | spec/\*\*/\*
### References
* [https://github.com/bbatsov/ruby-style-guide#predicate-methods](https://github.com/bbatsov/ruby-style-guide#predicate-methods)
## Style/OneLineConditional
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
TODO: Make configurable.
Checks for uses of if/then/else/end on a single line.
### References
* [https://github.com/bbatsov/ruby-style-guide#ternary-operator](https://github.com/bbatsov/ruby-style-guide#ternary-operator)
## Style/OpMethod
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop makes sure that certain binary operator methods have their
sole parameter named `other`.
### Example
```ruby
# bad
def +(amount); end
# good
def +(other); end
```
### References
* [https://github.com/bbatsov/ruby-style-guide#other-arg](https://github.com/bbatsov/ruby-style-guide#other-arg)
## Style/OptionHash
Enabled by default | Supports autocorrection
--- | ---
Disabled | No
This cop checks for options hashes and discourages them if the
current Ruby version supports keyword arguments.
### Example
```ruby
Instead of:
def fry(options = {})
temperature = options.fetch(:temperature, 300)
...
end
Prefer:
def fry(temperature: 300)
...
end
```
### Important attributes
Attribute | Value
--- | ---
SuspiciousParamNames | options, opts, args, params, parameters
## Style/OptionalArguments
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for optional arguments to methods
that do not come at the end of the argument list
### Example
```ruby
# bad
def foo(a = 1, b, c)
end
# good
def baz(a, b, c = 1)
end
def foobar(a = 1, b = 2, c = 3)
end
```
### References
* [https://github.com/bbatsov/ruby-style-guide#optional-arguments](https://github.com/bbatsov/ruby-style-guide#optional-arguments)
## Style/ParallelAssignment
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks for simple usages of parallel assignment.
This will only complain when the number of variables
being assigned matched the number of assigning variables.
### Example
```ruby
# bad
a, b, c = 1, 2, 3
a, b, c = [1, 2, 3]
# good
one, two = *foo
a, b = foo()
a, b = b, a
a = 1
b = 2
c = 3
```
### References
* [https://github.com/bbatsov/ruby-style-guide#parallel-assignment](https://github.com/bbatsov/ruby-style-guide#parallel-assignment)
## Style/ParenthesesAroundCondition
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for the presence of superfluous parentheses around the
condition of if/unless/while/until.
### Important attributes
Attribute | Value
--- | ---
AllowSafeAssignment | true
### References
* [https://github.com/bbatsov/ruby-style-guide#no-parens-around-condition](https://github.com/bbatsov/ruby-style-guide#no-parens-around-condition)
## Style/PercentLiteralDelimiters
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop enforces the consistent usage of `%`-literal delimiters.
Specify the 'default' key to set all preferred delimiters at once. You
can continue to specify individual preferred delimiters to override the
default.
### Example
```ruby
# Style/PercentLiteralDelimiters:
# PreferredDelimiters:
# default: ()
# %i: []
# good
%w(alpha beta) + %i[gamma delta]
# bad
%W[alpha #{beta}]
# bad
%I[alpha beta]
```
### Important attributes
Attribute | Value
--- | ---
PreferredDelimiters | {"default"=>"()", "%r"=>"{}"}
### References
* [https://github.com/bbatsov/ruby-style-guide#percent-literal-braces](https://github.com/bbatsov/ruby-style-guide#percent-literal-braces)
## Style/PercentQLiterals
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for usage of the %Q() syntax when %q() would do.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | lower_case_q
SupportedStyles | lower_case_q, upper_case_q
## Style/PerlBackrefs
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop looks for uses of Perl-style regexp match
backreferences like $1, $2, etc.
### References
* [https://github.com/bbatsov/ruby-style-guide#no-perl-regexp-last-matchers](https://github.com/bbatsov/ruby-style-guide#no-perl-regexp-last-matchers)
## Style/PredicateName
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop makes sure that predicates are named properly.
### Example
```ruby
# bad
def is_even?(value) ...
# good
def even?(value)
# bad
def has_value? ...
# good
def value? ...
```
### Important attributes
Attribute | Value
--- | ---
NamePrefix | is_, has_, have_
NamePrefixBlacklist | is_, has_, have_
NameWhitelist | is_a?
Exclude | spec/\*\*/\*
### References
* [https://github.com/bbatsov/ruby-style-guide#bool-methods-qmark](https://github.com/bbatsov/ruby-style-guide#bool-methods-qmark)
## Style/PreferredHashMethods
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop (by default) checks for uses of methods Hash#has_key? and
Hash#has_value? where it enforces Hash#key? and Hash#value?
It is configurable to enforce the inverse, using `verbose` method
names also.
### Example
```ruby
# EnforcedStyle: short (default)
# bad
Hash#has_key?
Hash#has_value?
# good
Hash#key?
Hash#value?
```
```ruby
# EnforcedStyle: verbose
# bad
Hash#key?
Hash#value?
# good
Hash#has_key?
Hash#has_value?
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | short
SupportedStyles | short, verbose
### References
* [https://github.com/bbatsov/ruby-style-guide#hash-key](https://github.com/bbatsov/ruby-style-guide#hash-key)
## Style/Proc
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cops checks for uses of Proc.new where Kernel#proc
would be more appropriate.
### References
* [https://github.com/bbatsov/ruby-style-guide#proc](https://github.com/bbatsov/ruby-style-guide#proc)
## Style/RaiseArgs
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks the args passed to `fail` and `raise`. For exploded
style (default), it recommends passing the exception class and message
to `raise`, rather than construct an instance of the error. It will
still allow passing just a message, or the construction of an error
with more than one argument.
The exploded style works identically, but with the addition that it
will also suggest constructing error objects when the exception is
passed multiple arguments.
### Example
```ruby
# EnforcedStyle: exploded
# bad
raise StandardError.new("message")
# good
raise StandardError, "message"
fail "message"
raise MyCustomError.new(arg1, arg2, arg3)
raise MyKwArgError.new(key1: val1, key2: val2)
```
```ruby
# EnforcedStyle: compact
# bad
raise StandardError, "message"
raise RuntimeError, arg1, arg2, arg3
# good
raise StandardError.new("message")
raise MyCustomError.new(arg1, arg2, arg3)
fail "message"
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | exploded
SupportedStyles | compact, exploded
### References
* [https://github.com/bbatsov/ruby-style-guide#exception-class-messages](https://github.com/bbatsov/ruby-style-guide#exception-class-messages)
## Style/RedundantBegin
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for redundant `begin` blocks.
Currently it checks for code like this:
### Example
```ruby
def redundant
begin
ala
bala
rescue StandardError => e
something
end
end
def preferred
ala
bala
rescue StandardError => e
something
end
```
### References
* [https://github.com/bbatsov/ruby-style-guide#begin-implicit](https://github.com/bbatsov/ruby-style-guide#begin-implicit)
## Style/RedundantException
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for RuntimeError as the argument of raise/fail.
It checks for code like this:
### Example
```ruby
# Bad
raise RuntimeError, 'message'
# Bad
raise RuntimeError.new('message')
# Good
raise 'message'
```
### References
* [https://github.com/bbatsov/ruby-style-guide#no-explicit-runtimeerror](https://github.com/bbatsov/ruby-style-guide#no-explicit-runtimeerror)
## Style/RedundantFreeze
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop check for uses of Object#freeze on immutable objects.
### Example
```ruby
# bad
CONST = 1.freeze
# good
CONST = 1
```
## Style/RedundantParentheses
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for redundant parentheses.
### Example
```ruby
# bad
(x) if ((y.z).nil?)
# good
x if y.z.nil?
```
## Style/RedundantReturn
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for redundant `return` expressions.
It should be extended to handle methods whose body is if/else
or a case expression with a default branch.
### Example
```ruby
def test
return something
end
def test
one
two
three
return something
end
```
### Important attributes
Attribute | Value
--- | ---
AllowMultipleReturnValues | false
### References
* [https://github.com/bbatsov/ruby-style-guide#no-explicit-return](https://github.com/bbatsov/ruby-style-guide#no-explicit-return)
## Style/RedundantSelf
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for redundant uses of `self`.
`self` is only needed when:
* Sending a message to same object with zero arguments in
presence of a method name clash with an argument or a local
variable.
Note, with using explicit self you can only send messages
with public or protected scope, you cannot send private
messages this way.
Example:
def bar
:baz
end
def foo(bar)
self.bar # resolves name clash with argument
end
def foo2
bar = 1
self.bar # resolves name clash with local variable
end
* Calling an attribute writer to prevent an local variable assignment
attr_writer :bar
def foo
self.bar= 1 # Make sure above attr writer is called
end
Special cases:
We allow uses of `self` with operators because it would be awkward
otherwise.
### References
* [https://github.com/bbatsov/ruby-style-guide#no-self-unless-required](https://github.com/bbatsov/ruby-style-guide#no-self-unless-required)
## Style/RegexpLiteral
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop enforces using // or %r around regular expressions.
### Example
```ruby
# Good if EnforcedStyle is slashes or mixed, bad if percent_r.
snake_case = /^[\dA-Z_]+$/
# Good if EnforcedStyle is percent_r, bad if slashes or mixed.
snake_case = %r{^[\dA-Z_]+$}
# Good if EnforcedStyle is slashes, bad if percent_r or mixed.
regex = /
foo
(bar)
(baz)
/x
# Good if EnforcedStyle is percent_r or mixed, bad if slashes.
regex = %r{
foo
(bar)
(baz)
}x
# Bad unless AllowInnerSlashes is true.
x =~ /home\//
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | slashes
SupportedStyles | slashes, percent_r, mixed
AllowInnerSlashes | false
### References
* [https://github.com/bbatsov/ruby-style-guide#percent-r](https://github.com/bbatsov/ruby-style-guide#percent-r)
## Style/RescueEnsureAlignment
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks whether the rescue and ensure keywords are aligned
properly.
### Example
```ruby
# bad
begin
something
rescue
puts 'error'
end
# good
begin
something
rescue
puts 'error'
end
```
## Style/RescueModifier
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for uses of rescue in its modifier form.
### References
* [https://github.com/bbatsov/ruby-style-guide#no-rescue-modifiers](https://github.com/bbatsov/ruby-style-guide#no-rescue-modifiers)
## Style/SafeNavigation
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop transforms usages of a method call safeguarded by a non `nil`
check for the variable whose method is being called to
safe navigation (`&.`).
Configuration option: ConvertCodeThatCanStartToReturnNil
The default for this is `false`. When configured to `true`, this will
check for code in the format `!foo.nil? && foo.bar`. As it is written,
the return of this code is limited to `false` and whatever the return
of the method is. If this is converted to safe navigation,
`foo&.bar` can start returning `nil` as well as what the method
returns.
### Example
```ruby
# bad
foo.bar if foo
foo.bar(param1, param2) if foo
foo.bar { |e| e.something } if foo
foo.bar(param) { |e| e.something } if foo
foo.bar if !foo.nil?
foo.bar unless !foo
foo.bar unless foo.nil?
foo && foo.bar
foo && foo.bar(param1, param2)
foo && foo.bar { |e| e.something }
foo && foo.bar(param) { |e| e.something }
# good
foo&.bar
foo&.bar(param1, param2)
foo&.bar { |e| e.something }
foo&.bar(param) { |e| e.something }
foo.nil? || foo.bar
!foo || foo.bar
# Methods that `nil` will `respond_to?` should not be converted to
# use safe navigation
foo.to_i if foo
```
### Important attributes
Attribute | Value
--- | ---
ConvertCodeThatCanStartToReturnNil | false
## Style/SelfAssignment
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop enforces the use the shorthand for self-assignment.
### Example
```ruby
# bad
x = x + 1
# good
x += 1
```
### References
* [https://github.com/bbatsov/ruby-style-guide#self-assignment](https://github.com/bbatsov/ruby-style-guide#self-assignment)
## Style/Semicolon
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for multiple expressions placed on the same line.
It also checks for lines terminated with a semicolon.
### Important attributes
Attribute | Value
--- | ---
AllowAsExpressionSeparator | false
### References
* [https://github.com/bbatsov/ruby-style-guide#no-semicolon](https://github.com/bbatsov/ruby-style-guide#no-semicolon)
## Style/Send
Enabled by default | Supports autocorrection
--- | ---
Disabled | No
This cop checks for the use of the send method.
### References
* [https://github.com/bbatsov/ruby-style-guide#prefer-public-send](https://github.com/bbatsov/ruby-style-guide#prefer-public-send)
## Style/SignalException
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for uses of `fail` and `raise`.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | only_raise
SupportedStyles | only_raise, only_fail, semantic
### References
* [https://github.com/bbatsov/ruby-style-guide#prefer-raise-over-fail](https://github.com/bbatsov/ruby-style-guide#prefer-raise-over-fail)
## Style/SingleLineBlockParams
Enabled by default | Supports autocorrection
--- | ---
Disabled | No
This cop checks whether the block parameters of a single-line
method accepting a block match the names specified via configuration.
For instance one can configure `reduce`(`inject`) to use |a, e| as
parameters.
### Important attributes
Attribute | Value
--- | ---
Methods | {"reduce"=>["acc", "elem"]}, {"inject"=>["acc", "elem"]}
## Style/SingleLineMethods
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for single-line method definitions.
It can optionally accept single-line methods with no body.
### Important attributes
Attribute | Value
--- | ---
AllowIfMethodIsEmpty | true
### References
* [https://github.com/bbatsov/ruby-style-guide#no-single-line-methods](https://github.com/bbatsov/ruby-style-guide#no-single-line-methods)
## Style/SpaceAfterColon
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks for colon (:) not followed by some kind of space.
N.B. this cop does not handle spaces after a ternary operator, which are
instead handled by Style/SpaceAroundOperators.
### References
* [https://github.com/bbatsov/ruby-style-guide#spaces-operators](https://github.com/bbatsov/ruby-style-guide#spaces-operators)
## Style/SpaceAfterComma
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks for comma (,) not followed by some kind of space.
### References
* [https://github.com/bbatsov/ruby-style-guide#spaces-operators](https://github.com/bbatsov/ruby-style-guide#spaces-operators)
## Style/SpaceAfterMethodName
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks for space between a method name and a left parenthesis in defs.
### Example
```ruby
# bad
def func (x) ... end
# good
def func(x) ... end
```
### References
* [https://github.com/bbatsov/ruby-style-guide#parens-no-spaces](https://github.com/bbatsov/ruby-style-guide#parens-no-spaces)
## Style/SpaceAfterNot
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for space after `!`.
### Example
```ruby
# bad
! something
# good
!something
```
### References
* [https://github.com/bbatsov/ruby-style-guide#no-space-bang](https://github.com/bbatsov/ruby-style-guide#no-space-bang)
## Style/SpaceAfterSemicolon
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks for semicolon (;) not followed by some kind of space.
### References
* [https://github.com/bbatsov/ruby-style-guide#spaces-operators](https://github.com/bbatsov/ruby-style-guide#spaces-operators)
## Style/SpaceAroundBlockParameters
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks the spacing inside and after block parameters pipes.
### Example
```ruby
# bad
{}.each { | x, y |puts x }
# good
{}.each { |x, y| puts x }
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyleInsidePipes | no_space
SupportedStylesInsidePipes | space, no_space
## Style/SpaceAroundEqualsInParameterDefault
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks that the equals signs in parameter default assignments
have or don't have surrounding space depending on configuration.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | space
SupportedStyles | space, no_space
### References
* [https://github.com/bbatsov/ruby-style-guide#spaces-around-equals](https://github.com/bbatsov/ruby-style-guide#spaces-around-equals)
## Style/SpaceAroundKeyword
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks the spacing around the keywords.
### Example
```ruby
# bad
something 'test'do|x|
end
while(something)
end
something = 123if test
# good
something 'test' do |x|
end
while (something)
end
something = 123 if test
```
## Style/SpaceAroundOperators
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks that operators have space around them, except for **
which should not have surrounding space.
### Important attributes
Attribute | Value
--- | ---
AllowForAlignment | true
### References
* [https://github.com/bbatsov/ruby-style-guide#spaces-operators](https://github.com/bbatsov/ruby-style-guide#spaces-operators)
## Style/SpaceBeforeBlockBraces
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks that block braces have or don't have a space before the opening
brace depending on configuration.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | space
SupportedStyles | space, no_space
## Style/SpaceBeforeComma
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks for comma (,) preceded by space.
## Style/SpaceBeforeComment
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for missing space between a token and a comment on the
same line.
## Style/SpaceBeforeFirstArg
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks that exactly one space is used between a method name and the
first argument for method calls without parentheses.
Alternatively, extra spaces can be added to align the argument with
something on a preceding or following line, if the AllowForAlignment
config parameter is true.
### Example
```ruby
# bad
something x
something y, z
# good
something x
something y, z
```
### Important attributes
Attribute | Value
--- | ---
AllowForAlignment | true
## Style/SpaceBeforeSemicolon
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks for semicolon (;) preceded by space.
## Style/SpaceInLambdaLiteral
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for spaces between -> and opening parameter
brace in lambda literals.
### Example
```ruby
EnforcedStyle: require_no_space (default)
# bad
a = -> (x, y) { x + y }
# good
a = ->(x, y) { x + y }
```
```ruby
EnforcedStyle: require_space
# bad
a = ->(x, y) { x + y }
# good
a = -> (x, y) { x + y }
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | require_no_space
SupportedStyles | require_no_space, require_space
## Style/SpaceInsideArrayPercentLiteral
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks for unnecessary additional spaces inside array percent literals
(i.e. %i/%w).
### Example
```ruby
# good
%i(foo bar baz)
# bad
%w(foo bar baz)
```
## Style/SpaceInsideBlockBraces
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks that block braces have or don't have surrounding space inside
them on configuration. For blocks taking parameters, it checks that the
left brace has or doesn't have trailing space depending on
configuration.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | space
SupportedStyles | space, no_space
EnforcedStyleForEmptyBraces | no_space
SupportedStylesForEmptyBraces | space, no_space
SpaceBeforeBlockParameters | true
## Style/SpaceInsideBrackets
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks for spaces inside square brackets.
### References
* [https://github.com/bbatsov/ruby-style-guide#no-spaces-braces](https://github.com/bbatsov/ruby-style-guide#no-spaces-braces)
## Style/SpaceInsideHashLiteralBraces
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks that braces used for hash literals have or don't have
surrounding space depending on configuration.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | space
SupportedStyles | space, no_space, compact
EnforcedStyleForEmptyBraces | no_space
SupportedStylesForEmptyBraces | space, no_space
### References
* [https://github.com/bbatsov/ruby-style-guide#spaces-operators](https://github.com/bbatsov/ruby-style-guide#spaces-operators)
## Style/SpaceInsideParens
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks for spaces inside ordinary round parentheses.
### References
* [https://github.com/bbatsov/ruby-style-guide#no-spaces-braces](https://github.com/bbatsov/ruby-style-guide#no-spaces-braces)
## Style/SpaceInsidePercentLiteralDelimiters
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks for unnecessary additional spaces inside the delimiters of
%i/%w/%x literals.
### Example
```ruby
# good
%i(foo bar baz)
# bad
%w( foo bar baz )
# bad
%x( ls -l )
```
## Style/SpaceInsideRangeLiteral
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks for spaces inside range literals.
### Example
```ruby
# bad
1 .. 3
# good
1..3
# bad
'a' .. 'z'
# good
'a'..'z'
```
### References
* [https://github.com/bbatsov/ruby-style-guide#no-space-inside-range-literals](https://github.com/bbatsov/ruby-style-guide#no-space-inside-range-literals)
## Style/SpaceInsideStringInterpolation
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for whitespace within string interpolations.
### Example
```ruby
# Good if EnforcedStyle is no_space, bad if space.
var = "This is the #{no_space} example"
# Good if EnforceStyle is space, bad if no_space.
var = "This is the #{ space } example"
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | no_space
SupportedStyles | space, no_space
### References
* [https://github.com/bbatsov/ruby-style-guide#string-interpolation](https://github.com/bbatsov/ruby-style-guide#string-interpolation)
## Style/SpecialGlobalVars
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop looks for uses of Perl-style global variables.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | use_english_names
SupportedStyles | use_perl_names, use_english_names
### References
* [https://github.com/bbatsov/ruby-style-guide#no-cryptic-perlisms](https://github.com/bbatsov/ruby-style-guide#no-cryptic-perlisms)
## Style/StabbyLambdaParentheses
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Check for parentheses around stabby lambda arguments.
There are two different styles. Defaults to `require_parentheses`.
### Example
```ruby
# require_parentheses - bad
->a,b,c { a + b + c }
# require_parentheses - good
->(a,b,c) { a + b + c}
# require_no_parentheses - bad
->(a,b,c) { a + b + c }
# require_no_parentheses - good
->a,b,c { a + b + c}
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | require_parentheses
SupportedStyles | require_parentheses, require_no_parentheses
### References
* [https://github.com/bbatsov/ruby-style-guide#stabby-lambda-with-args](https://github.com/bbatsov/ruby-style-guide#stabby-lambda-with-args)
## Style/StringLiterals
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks if uses of quotes match the configured preference.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | single_quotes
SupportedStyles | single_quotes, double_quotes
ConsistentQuotesInMultiline | false
### References
* [https://github.com/bbatsov/ruby-style-guide#consistent-string-literals](https://github.com/bbatsov/ruby-style-guide#consistent-string-literals)
## Style/StringLiteralsInInterpolation
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks if uses of quotes match the configured preference.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | single_quotes
SupportedStyles | single_quotes, double_quotes
## Style/StringMethods
Enabled by default | Supports autocorrection
--- | ---
Disabled | Yes
This cop enforces the use of consistent method names
from the String class.
### Important attributes
Attribute | Value
--- | ---
PreferredMethods | {"intern"=>"to_sym"}
## Style/StructInheritance
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop checks for inheritance from Struct.new.
### Example
```ruby
# bad
class Person < Struct.new(:first_name, :last_name)
end
# good
Person = Struct.new(:first_name, :last_name)
```
### References
* [https://github.com/bbatsov/ruby-style-guide#no-extend-struct-new](https://github.com/bbatsov/ruby-style-guide#no-extend-struct-new)
## Style/SymbolArray
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop can check for array literals made up of symbols that are not
using the %i() syntax.
Alternatively, it checks for symbol arrays using the %i() syntax on
projects which do not want to use that syntax, perhaps because they
support a version of Ruby lower than 2.0.
### Example
```ruby
EnforcedStyle: percent (default)
# good
%i[foo bar baz]
# bad
[:foo, :bar, :baz]
```
```ruby
EnforcedStyle: brackets
# good
[:foo, :bar, :baz]
# bad
%i[foo bar baz]
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | percent
SupportedStyles | percent, brackets
### References
* [https://github.com/bbatsov/ruby-style-guide#percent-i](https://github.com/bbatsov/ruby-style-guide#percent-i)
## Style/SymbolLiteral
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks symbol literal syntax.
### Example
```ruby
# bad
:"symbol"
# good
:symbol
```
## Style/SymbolProc
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Use symbols as procs when possible.
### Example
```ruby
# bad
something.map { |s| s.upcase }
# good
something.map(&:upcase)
```
### Important attributes
Attribute | Value
--- | ---
IgnoredMethods | respond_to, define_method
## Style/Tab
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for tabs inside the source code.
### References
* [https://github.com/bbatsov/ruby-style-guide#spaces-indentation](https://github.com/bbatsov/ruby-style-guide#spaces-indentation)
## Style/TernaryParentheses
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for the presence of parentheses around ternary
conditions. It is configurable to enforce inclusion or omission of
parentheses using `EnforcedStyle`. Omission is only enforced when
removing the parentheses won't cause a different behaviour.
### Example
```ruby
EnforcedStyle: require_no_parentheses (default)
# bad
foo = (bar?) ? a : b
foo = (bar.baz?) ? a : b
foo = (bar && baz) ? a : b
# good
foo = bar? ? a : b
foo = bar.baz? ? a : b
foo = bar && baz ? a : b
```
```ruby
EnforcedStyle: require_parentheses
# bad
foo = bar? ? a : b
foo = bar.baz? ? a : b
foo = bar && baz ? a : b
# good
foo = (bar?) ? a : b
foo = (bar.baz?) ? a : b
foo = (bar && baz) ? a : b
```
```ruby
EnforcedStyle: require_parentheses_when_complex
# bad
foo = (bar?) ? a : b
foo = (bar.baz?) ? a : b
foo = bar && baz ? a : b
# good
foo = bar? ? a : b
foo = bar.baz? ? a : b
foo = (bar && baz) ? a : b
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | require_no_parentheses
SupportedStyles | require_parentheses, require_no_parentheses, require_parentheses_when_complex
AllowSafeAssignment | true
## Style/TrailingBlankLines
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop looks for trailing blank lines and a final newline in the
source code.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | final_newline
SupportedStyles | final_newline, final_blank_line
### References
* [https://github.com/bbatsov/ruby-style-guide#newline-eof](https://github.com/bbatsov/ruby-style-guide#newline-eof)
## Style/TrailingCommaInArguments
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for trailing comma in argument lists.
### Example
```ruby
# always bad
method(1, 2,)
# good if EnforcedStyleForMultiline is consistent_comma
method(
1, 2,
3,
)
# good if EnforcedStyleForMultiline is comma or consistent_comma
method(
1,
2,
)
# good if EnforcedStyleForMultiline is no_comma
method(
1,
2
)
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyleForMultiline | no_comma
SupportedStylesForMultiline | comma, consistent_comma, no_comma
### References
* [https://github.com/bbatsov/ruby-style-guide#no-trailing-params-comma](https://github.com/bbatsov/ruby-style-guide#no-trailing-params-comma)
## Style/TrailingCommaInLiteral
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for trailing comma in array and hash literals.
### Example
```ruby
# always bad
a = [1, 2,]
# good if EnforcedStyleForMultiline is consistent_comma
a = [
1, 2,
3,
]
# good if EnforcedStyleForMultiline is comma or consistent_comma
a = [
1,
2,
]
# good if EnforcedStyleForMultiline is no_comma
a = [
1,
2
]
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyleForMultiline | no_comma
SupportedStylesForMultiline | comma, consistent_comma, no_comma
### References
* [https://github.com/bbatsov/ruby-style-guide#no-trailing-array-commas](https://github.com/bbatsov/ruby-style-guide#no-trailing-array-commas)
## Style/TrailingUnderscoreVariable
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for extra underscores in variable assignment.
### Example
```ruby
# bad
a, b, _ = foo()
a, b, _, = foo()
a, _, _ = foo()
a, _, _, = foo()
# good
a, b, = foo()
a, = foo()
*a, b, _ = foo() => We need to know to not include 2 variables in a
a, *b, _ = foo() => The correction `a, *b, = foo()` is a syntax error
# good if AllowNamedUnderscoreVariables is true
a, b, _something = foo()
```
### Important attributes
Attribute | Value
--- | ---
AllowNamedUnderscoreVariables | true
## Style/TrailingWhitespace
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop looks for trailing whitespace in the source code.
### References
* [https://github.com/bbatsov/ruby-style-guide#no-trailing-whitespace](https://github.com/bbatsov/ruby-style-guide#no-trailing-whitespace)
## Style/TrivialAccessors
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop looks for trivial reader/writer methods, that could
have been created with the attr_* family of functions automatically.
### Important attributes
Attribute | Value
--- | ---
ExactNameMatch | true
AllowPredicates | true
AllowDSLWriters | false
IgnoreClassMethods | false
Whitelist | to_ary, to_a, to_c, to_enum, to_h, to_hash, to_i, to_int, to_io, to_open, to_path, to_proc, to_r, to_regexp, to_str, to_s, to_sym
### References
* [https://github.com/bbatsov/ruby-style-guide#attr_family](https://github.com/bbatsov/ruby-style-guide#attr_family)
## Style/UnlessElse
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop looks for *unless* expressions with *else* clauses.
### References
* [https://github.com/bbatsov/ruby-style-guide#no-else-with-unless](https://github.com/bbatsov/ruby-style-guide#no-else-with-unless)
## Style/UnneededCapitalW
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for usage of the %W() syntax when %w() would do.
## Style/UnneededInterpolation
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for strings that are just an interpolated expression.
### Example
```ruby
# bad
"#{@var}"
# good
@var.to_s
# good if @var is already a String
@var
```
## Style/UnneededPercentQ
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for usage of the %q/%Q syntax when '' or "" would do.
### References
* [https://github.com/bbatsov/ruby-style-guide#percent-q](https://github.com/bbatsov/ruby-style-guide#percent-q)
## Style/VariableInterpolation
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for variable interpolation (like "#@ivar").
### References
* [https://github.com/bbatsov/ruby-style-guide#curlies-interpolate](https://github.com/bbatsov/ruby-style-guide#curlies-interpolate)
## Style/VariableName
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop makes sure that all variables use the configured style,
snake_case or camelCase, for their names.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | snake_case
SupportedStyles | snake_case, camelCase
### References
* [https://github.com/bbatsov/ruby-style-guide#snake-case-symbols-methods-vars](https://github.com/bbatsov/ruby-style-guide#snake-case-symbols-methods-vars)
## Style/VariableNumber
Enabled by default | Supports autocorrection
--- | ---
Enabled | No
This cop makes sure that all numbered variables use the
configured style, snake_case, normalcase or non_integer,
for their numbering.
### Example
```ruby
"EnforcedStyle => 'snake_case'"
# bad
variable1 = 1
# good
variable_1 = 1
```
```ruby
"EnforcedStyle => 'normalcase'"
# bad
variable_1 = 1
# good
variable1 = 1
```
```ruby
"EnforcedStyle => 'non_integer'"
#bad
variable1 = 1
variable_1 = 1
#good
variableone = 1
variable_one = 1
```
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | normalcase
SupportedStyles | snake_case, normalcase, non_integer
## Style/WhenThen
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for *when;* uses in *case* expressions.
### References
* [https://github.com/bbatsov/ruby-style-guide#one-line-cases](https://github.com/bbatsov/ruby-style-guide#one-line-cases)
## Style/WhileUntilDo
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks for uses of `do` in multi-line `while/until` statements.
### References
* [https://github.com/bbatsov/ruby-style-guide#no-multiline-while-do](https://github.com/bbatsov/ruby-style-guide#no-multiline-while-do)
## Style/WhileUntilModifier
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
Checks for while and until statements that would fit on one line
if written as a modifier while/until.
The maximum line length is configurable.
### Important attributes
Attribute | Value
--- | ---
MaxLineLength | 80
### References
* [https://github.com/bbatsov/ruby-style-guide#while-as-a-modifier](https://github.com/bbatsov/ruby-style-guide#while-as-a-modifier)
## Style/WordArray
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop can check for array literals made up of word-like
strings, that are not using the %w() syntax.
Alternatively, it can check for uses of the %w() syntax, in projects
which do not want to include that syntax.
### Important attributes
Attribute | Value
--- | ---
EnforcedStyle | percent
SupportedStyles | percent, brackets
MinSize | 0
WordRegex | (?-mix:\A[\p{Word}\n\t]+\z)
### References
* [https://github.com/bbatsov/ruby-style-guide#percent-w](https://github.com/bbatsov/ruby-style-guide#percent-w)
## Style/ZeroLengthPredicate
Enabled by default | Supports autocorrection
--- | ---
Enabled | Yes
This cop checks for numeric comparisons that can be replaced
by a predicate method, such as receiver.length == 0,
receiver.length > 0, receiver.length != 0,
receiver.length < 1 and receiver.size == 0 that can be
replaced by receiver.empty? and !receiver.empty.
### Example
```ruby
# bad
[1, 2, 3].length == 0
0 == "foobar".length
array.length < 1
{a: 1, b: 2}.length != 0
string.length > 0
hash.size > 0
# good
[1, 2, 3].empty?
"foobar".empty?
array.empty?
!{a: 1, b: 2}.empty?
!string.empty?
!hash.empty?
```
rubocop-0.48.1+dfsg.orig/manual/css/ 0000775 0000000 0000000 00000000000 13070542236 0017202 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/manual/css/extra.css 0000664 0000000 0000000 00000000543 13070542236 0021041 0 ustar 00root root 0000000 0000000 /* By default kbd doesn't stand out very much. Let's fix this! */
kbd {
padding: 3px 5px;
border: solid 1px #ccc;
background-color: #fcfcfc;
border-radius: 3px;
box-shadow: inset 0 -1px 0 #bbb;
display: inline-block;
}
/* The default font-size for code blocks is 75% which makes code
hard to read. */
code {
font-size: 90%;
}
rubocop-0.48.1+dfsg.orig/manual/development.md 0000664 0000000 0000000 00000000757 13070542236 0021267 0 ustar 00root root 0000000 0000000 ## Add a new cop
Use a rake task to generate a cop template.
```sh
$ bundle exec rake new_cop[Category/Name]
created
- lib/rubocop/cop/category/name.rb
- spec/rubocop/cop/category/name_spec.rb
Do 4 steps
- Add an entry to `New feature` section in CHANGELOG.md
- e.g. Add new `Category/Name` cop. ([@your_id][])
- Add `require 'lib/rubocop/cop/category/name'` into lib/rubocop.rb
- Add an entry into config/enabled.yml or config/disabled.yml
- Implement a new cop to the generated file!
```
rubocop-0.48.1+dfsg.orig/manual/extensions.md 0000664 0000000 0000000 00000003771 13070542236 0021143 0 ustar 00root root 0000000 0000000 ## Extensions
It's possible to extend RuboCop with custom cops and formatters.
### Loading Extensions
Besides the `--require` command line option you can also specify ruby
files that should be loaded with the optional `require` directive in the
`.rubocop.yml` file:
```yaml
require:
- ../my/custom/file.rb
- rubocop-extension
```
Note: The paths are directly passed to `Kernel.require`. If your
extension file is not in `$LOAD_PATH`, you need to specify the path as
relative path prefixed with `./` explicitly, or absolute path. Paths
starting with a `.` are resolved relative to `.rubocop.yml`.
### Custom Cops
You can configure the custom cops in your `.rubocop.yml` just like any
other cop.
#### Known Custom Cops
* [rubocop-rspec](https://github.com/nevir/rubocop-rspec) -
RSpec-specific analysis
* [rubocop-cask](https://github.com/caskroom/rubocop-cask) - Analysis
for Homebrew-Cask files.
* [rubocop-thread_safety](https://github.com/covermymeds/rubocop-thread_safety) -
Thread-safety analysis
### Custom Formatters
You can customize RuboCop's output format with custom formatters.
#### Creating a Custom Formatter
To implement a custom formatter, you need to subclass
`RuboCop::Formatter::BaseFormatter` and override some methods,
or implement all formatter API methods by duck typing.
Please see the documents below for more formatter API details.
* [RuboCop::Formatter::BaseFormatter](http://www.rubydoc.info/gems/rubocop/RuboCop/Formatter/BaseFormatter)
* [RuboCop::Cop::Offense](http://www.rubydoc.info/gems/rubocop/RuboCop/Cop/Offense)
* [Parser::Source::Range](http://www.rubydoc.info/github/whitequark/parser/Parser/Source/Range)
#### Using a Custom Formatter from the Command Line
You can tell RuboCop to use your custom formatter with a combination of
`--format` and `--require` option.
For example, when you have defined `MyCustomFormatter` in
`./path/to/my_custom_formatter.rb`, you would type this command:
```sh
$ rubocop --require ./path/to/my_custom_formatter --format MyCustomFormatter
```
rubocop-0.48.1+dfsg.orig/manual/formatters.md 0000664 0000000 0000000 00000015614 13070542236 0021131 0 ustar 00root root 0000000 0000000 ## Formatters
You can change the output format of RuboCop by specifying formatters with the `-f/--format` option.
RuboCop ships with several built-in formatters, and also you can create your custom formatter.
Additionally the output can be redirected to a file instead of `$stdout` with the `-o/--out` option.
Some of the built-in formatters produce **machine-parsable** output
and they are considered public APIs.
The rest of the formatters are for humans, so parsing their outputs is discouraged.
You can enable multiple formatters at the same time by specifying `-f/--format` multiple times.
The `-o/--out` option applies to the previously specified `-f/--format`,
or the default `progress` format if no `-f/--format` is specified before the `-o/--out` option.
```sh
# Simple format to $stdout.
$ rubocop --format simple
# Progress (default) format to the file result.txt.
$ rubocop --out result.txt
# Both progress and offense count formats to $stdout.
# The offense count formatter outputs only the final summary,
# so you'll mostly see the outputs from the progress formatter,
# and at the end the offense count summary will be outputted.
$ rubocop --format progress --format offenses
# Progress format to $stdout, and JSON format to the file rubocop.json.
$ rubocop --format progress --format json --out rubocop.json
# ~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~
# | |_______________|
# $stdout
# Progress format to result.txt, and simple format to $stdout.
$ rubocop --output result.txt --format simple
# ~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~
# | |
# default format $stdout
```
You can also load [custom formatters](#custom-formatters).
### Progress Formatter (default)
The default `progress` formatter outputs a character for each inspected file,
and at the end it displays all detected offenses in the `clang` format.
A `.` represents a clean file, and each of the capital letters means
the severest offense (convention, warning, error or fatal) found in a file.
```sh
$ rubocop
Inspecting 26 files
..W.C....C..CWCW.C...WC.CC
Offenses:
lib/foo.rb:6:5: C: Missing top-level class documentation comment.
class Foo
^^^^^
...
26 files inspected, 46 offenses detected
```
### Clang Style Formatter
The `clang` formatter displays the offenses in a manner similar to `clang`:
```sh
$ rubocop test.rb
Inspecting 1 file
W
Offenses:
test.rb:1:5: C: Use snake_case for method names.
def badName
^^^^^^^
test.rb:2:3: C: Use a guard clause instead of wrapping the code inside a conditional expression.
if something
^^
test.rb:2:3: C: Favor modifier if usage when having a single-line body. Another good alternative is the usage of control flow &&/||.
if something
^^
test.rb:4:5: W: end at 4, 4 is not aligned with if at 2, 2
end
^^^
1 file inspected, 4 offenses detected
```
### Fuubar Style Formatter
The `fuubar` style formatter displays a progress bar
and shows details of offenses in the `clang` format as soon as they are detected.
This is inspired by the [Fuubar](https://github.com/thekompanee/fuubar) formatter for RSpec.
```sh
$ rubocop --format fuubar
lib/foo.rb.rb:1:1: C: Use snake_case for methods and variables.
def badName
^^^^^^^
lib/bar.rb:13:14: W: File.exists? is deprecated in favor of File.exist?.
File.exists?(path)
^^^^^^^
22/53 files |======== 43 ========> | ETA: 00:00:02
```
### Emacs Style Formatter
**Machine-parsable**
The `emacs` formatter displays the offenses in a format suitable for consumption by `Emacs` (and possibly other tools).
```sh
$ rubocop --format emacs test.rb
/Users/bozhidar/projects/test.rb:1:1: C: Use snake_case for methods and variables.
/Users/bozhidar/projects/test.rb:2:3: C: Favor modifier if/unless usage when you have a single-line body. Another good alternative is the usage of control flow &&/||.
/Users/bozhidar/projects/test.rb:4:5: W: end at 4, 4 is not aligned with if at 2, 2
```
### Simple Formatter
The name of the formatter says it all :-)
```sh
$ rubocop --format simple test.rb
== test.rb ==
C: 1: 5: Use snake_case for method names.
C: 2: 3: Use a guard clause instead of wrapping the code inside a conditional expression.
C: 2: 3: Favor modifier if usage when having a single-line body. Another good alternative is the usage of control flow &&/||.
W: 4: 5: end at 4, 4 is not aligned with if at 2, 2
1 file inspected, 4 offenses detected
```
### File List Formatter
**Machine-parsable**
Sometimes you might want to just open all files with offenses in your
favorite editor. This formatter outputs just the names of the files
with offenses in them and makes it possible to do something like:
```sh
$ rubocop --format files | xargs vim
```
### JSON Formatter
**Machine-parsable**
You can get RuboCop's inspection result in JSON format by passing `--format json` option in command line.
The JSON structure is like the following example:
```javascript
{
"metadata": {
"rubocop_version": "0.9.0",
"ruby_engine": "ruby",
"ruby_version": "2.0.0",
"ruby_patchlevel": "195",
"ruby_platform": "x86_64-darwin12.3.0"
},
"files": [{
"path": "lib/foo.rb",
"offenses": []
}, {
"path": "lib/bar.rb",
"offenses": [{
"severity": "convention",
"message": "Line is too long. [81/80]",
"cop_name": "LineLength",
"corrected": true,
"location": {
"line": 546,
"column": 80,
"length": 4
}
}, {
"severity": "warning",
"message": "Unreachable code detected.",
"cop_name": "UnreachableCode",
"corrected": false,
"location": {
"line": 15,
"column": 9,
"length": 10
}
}
]
}
],
"summary": {
"offense_count": 2,
"target_file_count": 2,
"inspected_file_count": 2
}
}
```
### Offense Count Formatter
Sometimes when first applying RuboCop to a codebase, it's nice to be able to
see where most of your style cleanup is going to be spent.
With this in mind, you can use the offense count formatter to outline the offended
cops and the number of offenses found for each by running:
```sh
$ rubocop --format offenses
87 Documentation
12 DotPosition
8 AvoidGlobalVars
7 EmptyLines
6 AssignmentInCondition
4 Blocks
4 CommentAnnotation
3 BlockAlignment
1 IndentationWidth
1 AvoidPerlBackrefs
1 ColonMethodCall
--
134 Total
```
### Worst Offenders Formatter
Similar to the Offense Count formatter, but lists the files which need the most attention:
```sh
$ rubocop --format worst
89 this/file/is/really/bad.rb
2 much/better.rb
--
91 Total
```
### HTML Formatter
Useful for CI environments. It will create an HTML report like [this](http://f.cl.ly/items/0M3029412x3O091a1X1R/expected.html).
```sh
$ rubocop --format html -o rubocop.html
```
rubocop-0.48.1+dfsg.orig/manual/index.md 0000664 0000000 0000000 00000001234 13070542236 0020043 0 ustar 00root root 0000000 0000000
> Role models are important.
> -- Officer Alex J. Murphy / RoboCop
**RuboCop** is a Ruby static code analyzer. Out of the box it will
enforce many of the guidelines outlined in the community
[Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide).
Most aspects of its behavior can be tweaked via various
[configuration options](https://github.com/bbatsov/rubocop/blob/master/config/default.yml).
Apart from reporting problems in your code, RuboCop can also
automatically fix some of the problems for you.
rubocop-0.48.1+dfsg.orig/manual/installation.md 0000664 0000000 0000000 00000001036 13070542236 0021435 0 ustar 00root root 0000000 0000000 **RuboCop**'s installation is pretty standard:
```sh
$ gem install rubocop
```
If you'd rather install RuboCop using `bundler`, don't require it in your `Gemfile`:
```rb
gem 'rubocop', require: false
```
RuboCop's development is moving at a very rapid pace and there are
often backward-incompatible changes between minor releases (since we
haven't reached version 1.0 yet). To prevent an unwanted RuboCop update you
might want to use a conservative version locking in your `Gemfile`:
```rb
gem 'rubocop', '~> 0.48.1', require: false
```
rubocop-0.48.1+dfsg.orig/manual/integration_with_other_tools.md 0000664 0000000 0000000 00000006303 13070542236 0024735 0 ustar 00root root 0000000 0000000 ## Editor integration
### Emacs
[rubocop.el](https://github.com/bbatsov/rubocop-emacs) is a simple
Emacs interface for RuboCop. It allows you to run RuboCop inside Emacs
and quickly jump between problems in your code.
[flycheck](https://github.com/flycheck/flycheck) > 0.9 also supports
RuboCop and uses it by default when available.
### Vim
The [vim-rubocop](https://github.com/ngmy/vim-rubocop) plugin runs
RuboCop and displays the results in Vim.
There's also a RuboCop checker in
[syntastic](https://github.com/scrooloose/syntastic),
[neomake](https://github.com/neomake/neomake)
and [ale](https://github.com/w0rp/ale).
### Sublime Text
If you're a ST user you might find the
[Sublime RuboCop plugin](https://github.com/pderichs/sublime_rubocop)
useful.
### Brackets
The [brackets-rubocop](https://github.com/smockle-archive/brackets-rubocop)
extension displays RuboCop results in Brackets.
It can be installed via the extension manager in Brackets.
### TextMate2
The [textmate2-rubocop](https://github.com/mrdougal/textmate2-rubocop)
bundle displays formatted RuboCop results in a new window.
Installation instructions can be found [here](https://github.com/mrdougal/textmate2-rubocop#installation).
### Atom
The [linter-rubocop](https://github.com/AtomLinter/linter-rubocop) plugin for Atom's
[linter](https://github.com/AtomLinter/Linter) runs RuboCop and highlights the offenses in Atom.
### LightTable
The [lt-rubocop](https://github.com/seancaffery/lt-rubocop) plugin
provides LightTable integration.
### RubyMine / Intellij IDEA
RuboCop support is [available](https://www.jetbrains.com/help/idea/2017.1/rubocop.html) as of the 2017.1 releases.
### Visual Studio Code
The [ruby](https://marketplace.visualstudio.com/items?itemName=rebornix.Ruby) extension
provides RuboCop integration for Visual Studio Code. RuboCop is also used for the formatting
capabilities of this extension.
### Other Editors
Here's one great opportunity to contribute to RuboCop - implement
RuboCop integration for your favorite editor.
## Git pre-commit hook integration
[overcommit](https://github.com/brigade/overcommit) is a fully configurable and
extendable Git commit hook manager. To use RuboCop with overcommit, add the
following to your `.overcommit.yml` file:
```yaml
PreCommit:
RuboCop:
enabled: true
```
## Guard integration
If you're fond of [Guard](https://github.com/guard/guard) you might
like
[guard-rubocop](https://github.com/yujinakayama/guard-rubocop). It
allows you to automatically check Ruby code style with RuboCop when
files are modified.
## Rake integration
To use RuboCop in your `Rakefile` add the following:
```ruby
require 'rubocop/rake_task'
RuboCop::RakeTask.new
```
If you run `rake -T`, the following two RuboCop tasks should show up:
```sh
rake rubocop # Run RuboCop
rake rubocop:auto_correct # Auto-correct RuboCop offenses
```
The above will use default values
```ruby
require 'rubocop/rake_task'
desc 'Run RuboCop on the lib directory'
RuboCop::RakeTask.new(:rubocop) do |task|
task.patterns = ['lib/**/*.rb']
# only show the files with failures
task.formatters = ['files']
# don't abort rake on failure
task.fail_on_error = false
end
```
rubocop-0.48.1+dfsg.orig/manual/support.md 0000664 0000000 0000000 00000002443 13070542236 0020453 0 ustar 00root root 0000000 0000000 RuboCop currently has several official & unofficial support channels.
For questions, suggestions and support refer to one of them. Please, don't
use the support channels to report issues, as this makes them harder to track.
## Gitter
Most internal discussions about the development of RuboCop happen on its
[gitter channel](https://gitter.im/bbatsov/rubocop). You can often find
RuboCop's maintainers there and get some interesting news from the project's
kitchen.
## Mailing List
The [official mailing list](https://groups.google.com/forum/#!forum/rubocop) is
hosted at Google Groups. It's a low-traffic list, so don't be too hesitant to subscribe.
## Freenode
If you're into IRC you can visit the `#rubocop` channel on Freenode.
It's not actively
monitored by the RuboCop maintainers themselves, but still you can get support
from other RuboCop users there.
## Stackoverflow
We're also encouraging users to ask RuboCop-related questions on StackOverflow.
When doing so you should use the
[RuboCop](http://stackoverflow.com/questions/tagged/rubocop) tag (ideally combined
with the tag `ruby`).
## Bountysource
If you're willing to pay for some feature to be implemented you can use
[Bountysource](https://www.bountysource.com/teams/rubocop/issues) to place a
bounty for the work you want to be done.
rubocop-0.48.1+dfsg.orig/mkdocs.yml 0000664 0000000 0000000 00000001675 13070542236 0017151 0 ustar 00root root 0000000 0000000 site_name: "RuboCop: The Ruby Linter that Serves and Protects"
repo_url: https://github.com/bbatsov/rubocop
site_favicon: favicon.ico
copyright: "Copyright (C) 2016 Bozhidar Batsov and RuboCop contributors"
docs_dir: manual
pages:
- Home: index.md
- Installation: installation.md
- Basic Usage: basic_usage.md
- Cops: cops.md
- Formatters: formatters.md
- Configuration: configuration.md
- Caching: caching.md
- Extensions: extensions.md
- Integration with other tools: integration_with_other_tools.md
- Automated Code Review: automated_code_review.md
- Support: support.md
- Contributing: contributing.md
- Development: development.md
- Cops Documentation:
- Linting Cops: cops_lint.md
- Metrics Cops: cops_metrics.md
- Performance Cops: cops_performance.md
- Rails Cops: cops_rails.md
- Security Cops: cops_security.md
- Style Cops: cops_style.md
- Bundler Cops: cops_bundler.md
extra_css:
- css/extra.css
theme: readthedocs
rubocop-0.48.1+dfsg.orig/relnotes/ 0000775 0000000 0000000 00000000000 13070542236 0016770 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/relnotes/v0.19.0.md 0000664 0000000 0000000 00000017333 13070542236 0020234 0 ustar 00root root 0000000 0000000 This is the biggest RuboCop release we've done in a while. The highlights include
about a dozen new cops, more cop configuration options, improved auto-correct and so many bugfixes.
You'll might note that we changed the use of `offence` with `offense`. This was done to keep the spelling
in our code consistent. Hopefully this won't cause anyone problems, but we're obliged to mention it as
the `Offence` class itself got renamed.
Below is the list of all the gory details. Enjoy!
## RuboCop 0.19.0
### New features
* New cop `FileName` makes sure that source files have snake_case names. ([@bbatsov][])
* New cop `DeprecatedClassMethods` checks for deprecated class methods. ([@bbatsov][])
* New cop `StringConversionInInterpolation` checks for redundant `Object#to_s` in string interpolation. ([@bbatsov][])
* New cop `LiteralInInterpolation` checks for interpolated string literals. ([@bbatsov][])
* New cop `SelfAssignment` checks for places where the self-assignment shorthand should have been used. ([@bbatsov][])
* New cop `DoubleNegation` checks for uses of `!!`. ([@bbatsov][])
* New cop `PercentLiteralDelimiters` enforces consistent usage of `%`-literal delimiters. ([@hannestyden][])
* New Rails cop `ActionFilter` enforces the use of `_filter` or `_action` action filter methods. ([@bbatsov][])
* New Rails cop `ScopeArgs` makes sure you invoke the `scope` method properly. ([@bbatsov][])
* Add `with_fixed_indentation` style to `AlignParameters` cop. ([@hannestyden][])
* Add `IgnoreLastArgumentHash` option to `AlignHash` cop. ([@hannestyden][])
* [#743](https://github.com/bbatsov/rubocop/issues/743): `SingleLineMethods` cop does auto-correction. ([@jonas054][])
* [#743](https://github.com/bbatsov/rubocop/issues/743): `Semicolon` cop does auto-correction. ([@jonas054][])
* [#743](https://github.com/bbatsov/rubocop/issues/743): `EmptyLineBetweenDefs` cop does auto-correction. ([@jonas054][])
* [#743](https://github.com/bbatsov/rubocop/issues/743): `IndentationWidth` cop does auto-correction. ([@jonas054][])
* [#743](https://github.com/bbatsov/rubocop/issues/743): `IndentationConsistency` cop does auto-correction. ([@jonas054][])
* [#809](https://github.com/bbatsov/rubocop/issues/809): New formatter `fuubar` displays a progress bar and shows details of offenses as soon as they are detected. ([@yujinakayama][])
* [#797](https://github.com/bbatsov/rubocop/issues/797): New cop `IndentHash` checks the indentation of the first key in multi-line hash literals. ([@jonas054][])
* [#797](https://github.com/bbatsov/rubocop/issues/797): New cop `IndentArray` checks the indentation of the first element in multi-line array literals. ([@jonas054][])
* [#806](https://github.com/bbatsov/rubocop/issues/806): Now excludes files in `vendor/**` by default. ([@jeremyolliver][])
* [#795](https://github.com/bbatsov/rubocop/issues/795): `IfUnlessModifier` and `WhileUntilModifier` supports `MaxLineLength`, which is independent of `LineLength` parameter `Max`. ([@agrimm][])
* [#868](https://github.com/bbatsov/rubocop/issues/868): New cop `ClassAndModuleChildren` checks the style of children definitions at classes and modules: nested / compact. ([@geniou][])
### Changes
* [#793](https://github.com/bbatsov/rubocop/issues/793): Add printing total count when `rubocop --format offences`. ([@ma2gedev][])
* Remove `Ignore` param from the Rails `Output` cop. The standard `Exclude/Include` should be used instead. ([@bbatsov][])
* Renamed `FavorSprintf` to `FormatString` and made it configurable. ([@bbatsov][])
* Renamed `Offence` to `Offense`. ([@bbatsov][])
* Use `offense` in all messages instead of `offence`. ([@bbatsov][])
* For indentation of `if`/`unless`/`while`/`until` bodies when the result is assigned to a variable, instead of supporting two styles simultaneously, `IndentationWidth` now supports one style of indentation at a time, specified by `EndAlignment`/`AlignWith`. ([@jonas054][])
* Renamed `Style` param of `DotPosition` cop to `EnforcedStyle`. ([@bbatsov][])
* Add `length` value to locations of offense in JSON formatter. ([@yujinakayama][])
* `SpaceAroundBlockBraces` cop replaced by `SpaceBeforeBlockBraces` and `SpaceInsideBlockBraces`. ([@jonas054][])
* `SpaceAroundEqualsInParameterDefault` cop is now configurable with the `EnforcedStyle` option. ([@jonas054][])
### Bugs fixed
* [#790](https://github.com/bbatsov/rubocop/issues/790): Fix auto-correction interference problem between `MethodDefParentheses` and other cops. ([@jonas054][])
* [#794](https://github.com/bbatsov/rubocop/issues/794): Fix handling of modifier keywords with required parentheses in `ParenthesesAroundCondition`. ([@bbatsov][])
* [#804](https://github.com/bbatsov/rubocop/issues/804): Fix a false positive with operator assignments in a loop (including `begin..rescue..end` with `retry`) in `UselessAssignment`. ([@yujinakayama][])
* [#815](https://github.com/bbatsov/rubocop/issues/815): Fix a false positive for heredocs with blank lines in them in `EmptyLines`. ([@bbatsov][])
* Auto-correction is now more robust and less likely to die because of `RangeError` or "clobbering". ([@jonas054][])
* Offenses always reported in order of position in file, also during `--auto-correct` runs. ([@jonas054][])
* Fix problem with `[Corrected]` tag sometimes missing in output from `--auto-correct` runs. ([@jonas054][])
* Fix message from `EndAlignment` cop when `AlignWith` is `keyword`. ([@jonas054][])
* Handle `case` conditions in `LiteralInCondition`. ([@bbatsov][])
* [#822](https://github.com/bbatsov/rubocop/issues/822): Fix a false positive in `DotPosition` when enforced style is set to `trailing`. ([@bbatsov][])
* Handle properly dynamic strings in `LineEndConcatenation`. ([@bbatsov][])
* [#832](https://github.com/bbatsov/rubocop/issues/832): Fix auto-correction interference problem between `BracesAroundHashParameters` and `SpaceInsideHashLiteralBraces`. ([@jonas054][])
* Fix bug in auto-correction of alignment so that only space can be removed. ([@jonas054][])
* Fix bug in `IndentationWidth` auto-correction so it doesn't correct things that `IndentationConsistency` should correct. ([@jonas054][])
* [#847](https://github.com/bbatsov/rubocop/issues/847): Fix bug in `RegexpLiteral` concerning `--auto-gen-config`. ([@jonas054][])
* [#848](https://github.com/bbatsov/rubocop/issues/848): Fix bug in `--show-cops` that made it print the default configuration rather than the current configuration. ([@jonas054][])
* [#862](https://github.com/bbatsov/rubocop/issues/862): Fix a bug where single line `rubocop:disable` comments with indentations were treated as multiline cop disabling comments. ([@yujinakayama][])
* Fix a bug where `rubocop:disable` comments with a cop name including `all` (e.g. `MethodCallParentheses`) were disabling all cops. ([@yujinakayama][])
* Fix a bug where string and regexp literals including `# rubocop:disable` were confused with real comments. ([@yujinakayama][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
rubocop-0.48.1+dfsg.orig/relnotes/v0.19.1.md 0000664 0000000 0000000 00000002351 13070542236 0020227 0 ustar 00root root 0000000 0000000 RuboCop 0.19.1 is a bugfix-only release. Below is a list of the bugs we've fixed since 0.19.0:
### Bugs fixed
* [#884](https://github.com/bbatsov/rubocop/issues/884): Fix --auto-gen-config for `NumericLiterals` so MinDigits is correct. ([@tmorris-fiksu][])
* [#879](https://github.com/bbatsov/rubocop/issues/879): Fix --auto-gen-config for `RegexpLiteral` so we don't generate illegal values for `MaxSlashes`. ([@jonas054][])
* Fix the name of the `Include` param in the default config of the Rails cops. ([@bbatsov][])
* [#878](https://github.com/bbatsov/rubocop/pull/878): Blacklist `Rakefile`, `Gemfile` and `Capfile` by default in the `FileName` cop. ([@bbatsov][])
* [#875](https://github.com/bbatsov/rubocop/issues/875): Handle `separator` style hashes in `IndentHash`. ([@jonas054][])
* Fix a bug where multiple cli options that result in exit can be specified at once (e.g. `-vV`, `-v --show-cops`). ([@jkogara][])
* [#889](https://github.com/bbatsov/rubocop/issues/889): Fix a false positive for `LiteralInCondition` when the condition is non-primitive array. ([@bbatsov][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
rubocop-0.48.1+dfsg.orig/relnotes/v0.20.0.md 0000664 0000000 0000000 00000013262 13070542236 0020221 0 ustar 00root root 0000000 0000000 There aren't many exciting new features this time around - our focus in 0.20 has been fixing most of the problems we
introduced in 0.19. Apart from that we've added a few new cops and implemented auto-correct for a bunch of the existing cops.
You'll also notice that the messages produced by most formatters a bit more colorful (and hopefully more readable as well).
You should also note that `AllCops/Includes` and `AllCops/Excludes` have been renamed, so you'll have to update your config files
accordingly.
Below is the list of all the gory details. Enjoy!
### New features
* New cop `GuardClause` checks for conditionals that can be replaced by guard clauses. ([@bbatsov][])
* New cop `EmptyInterpolation` checks for empty interpolation in double-quoted strings. ([@bbatsov][])
* [#899](https://github.com/bbatsov/rubocop/issues/899): Make `LineEndConcatenation` cop `<<` aware. ([@mockdeep][])
* [#896](https://github.com/bbatsov/rubocop/issues/896): New option `--fail-level` changes minimum severity for exit with error code. ([@hiroponz][])
* [#893](https://github.com/bbatsov/rubocop/issues/893): New option `--force-exclusion` forces excluding files specified in the configuration `Exclude` even if they are explicitly passed as arguments. ([@yujinakayama][])
* `VariableInterpolation` cop does auto-correction. ([@bbatsov][])
* `Not` cop does auto-correction. ([@bbatsov][])
* `ClassMethods` cop does auto-correction. ([@bbatsov][])
* `StringConversionInInterpolation` cop does auto-correction. ([@bbatsov][])
* `NilComparison` cop does auto-correction. ([@bbatsov][])
* `NonNilComparison` cop does auto-correction. ([@bbatsov][])
* `NegatedIf` cop does auto-correction. ([@bbatsov][])
* `NegatedWhile` cop does auto-correction. ([@bbatsov][])
* New lint cop `SpaceBeforeFirstArg` checks for space between the method name and the first argument in method calls without parentheses. ([@jonas054][])
* New style cop `SingleSpaceBeforeFirstArg` checks that no more than one space is used between the method name and the first argument in method calls without parentheses. ([@jonas054][])
* New formatter `disabled_lines` displays cops and line ranges disabled by inline comments. ([@fshowalter][])
* New cop `UselessAccessModifiers` checks for access modifiers that have no effect. ([@fshowalter][])
### Changes
* [#913](https://github.com/bbatsov/rubocop/issues/913): `FileName` accepts multiple extensions. ([@tamird][])
* `AllCops/Excludes` and `AllCops/Includes` were renamed to `AllCops/Exclude` and `AllCops/Include` for consistency with standard cop params. ([@bbatsov][])
* Extract `NonNilCheck` cop from `NilComparison`. ([@bbatsov][])
* Renamed `FavorJoin` to `ArrayJoin`. ([@bbatsov][])
* Renamed `FavorUnlessOverNegatedIf` to `NegatedIf`. ([@bbatsov][])
* Renamed `FavorUntilOverNegatedWhile`to `NegatedWhile`. ([@bbatsov][])
* Renamed `HashMethods` to `DeprecatedHashMethods`. ([@bbatsov][])
* Renamed `ReadAttribute` to `ReadWriteAttribute` and extended it to check for uses of `write_attribute`. ([@bbatsov][])
* Add experimental support for Ruby 2.2 (development version) by falling back to Ruby 2.1 parser. ([@yujinakayama][])
### Bugs fixed
* [#926](https://github.com/bbatsov/rubocop/issues/926): Fixed `BlockNesting` not auto-generating correctly. ([@tmorris-fiksu][])
* [#904](https://github.com/bbatsov/rubocop/issues/904): Fixed a NPE in `LiteralInInterpolation`. ([@bbatsov][])
* [#904](https://github.com/bbatsov/rubocop/issues/904): Fixed a NPE in `StringConversionInInterpolation`. ([@bbatsov][])
* [#892](https://github.com/bbatsov/rubocop/issues/892): Make sure `Include` and `Exclude` paths in a `.rubocop.yml` are interpreted as relative to the directory of that file. ([@jonas054][])
* [#906](https://github.com/bbatsov/rubocop/issues/906): Fixed a false positive in `LiteralInInterpolation`. ([@bbatsov][])
* [#909](https://github.com/bbatsov/rubocop/issues/909): Handle properly multiple `rescue` clauses in `SignalException`. ([@bbatsov][])
* [#876](https://github.com/bbatsov/rubocop/issues/876): Do a deep merge of hashes when overriding default configuration in a `.rubocop.yml` file. ([@jonas054][])
* [#912](https://github.com/bbatsov/rubocop/issues/912): Fix a false positive in `LineEndConcatenation` for `%` string literals. ([@bbatsov][])
* [#912](https://github.com/bbatsov/rubocop/issues/912): Handle top-level constant resolution in `DeprecatedClassMethods` (e.g. `::File.exists?`). ([@bbatsov][])
* [#914](https://github.com/bbatsov/rubocop/issues/914): Fixed rdoc error during gem installation. ([@bbatsov][])
* The `--only` option now enables the given cop in case it is disabled in configuration. ([@jonas054][])
* Fix path resolution so that the default exclusion of `vendor` directories works. ([@jonas054][])
* [#908](https://github.com/bbatsov/rubocop/issues/908): Fixed hanging while auto correct for `SpaceAfterComma` and `SpaceInsideBrackets`. ([@hiroponz][])
* [#919](https://github.com/bbatsov/rubocop/issues/919): Don't avoid auto-correction in `HashSyntax` when there is missing space around operator. ([@jonas054][])
* Fixed handling of floats in `NumericLiterals`. ([@bbatsov][])
* [#927](https://github.com/bbatsov/rubocop/issues/927): Let `--auto-gen-config` overwrite an existing `rubocop-todo.yml` file instead of asking the user to remove it. ([@jonas054][])
* [#936](https://github.com/bbatsov/rubocop/issues/936): Allow `_other` as well as `other` in `OpMethod`. ([@bbatsov][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
rubocop-0.48.1+dfsg.orig/relnotes/v0.20.1.md 0000664 0000000 0000000 00000003712 13070542236 0020221 0 ustar 00root root 0000000 0000000 RuboCop 0.20.1 is a bugfix-only release. Below is a list of the bugs we've fixed since 0.20.0:
## 0.20.1 (05/04/2014)
### Bugs fixed
* [#940](https://github.com/bbatsov/rubocop/issues/940): Fixed `UselessAccessModifier` not handling `attr_*` correctly. ([@fshowalter][])
* `NegatedIf` properly handles negated `unless` condition. ([@bbatsov][])
* `NegatedWhile` properly handles negated `until` condition. ([@bbatsov][])
* [#925](https://github.com/bbatsov/rubocop/issues/925): Do not disable the `Syntax` cop in output from `--auto-gen-config`. ([@jonas054][])
* [#943](https://github.com/bbatsov/rubocop/issues/943): Fix auto-correction interference problem between `SpaceAfterComma` and other cops. ([@jonas054][])
* [#954](https://github.com/bbatsov/rubocop/pull/954): Fix auto-correction bug in `NilComparison`. ([@bbatsov][])
* [#953](https://github.com/bbatsov/rubocop/pull/953): Fix auto-correction bug in `NonNilCheck`. ([@bbatsov][])
* [#952](https://github.com/bbatsov/rubocop/pull/952): Handle implicit receiver in `StringConversionInInterpolation`. ([@bbatsov][])
* [#956](https://github.com/bbatsov/rubocop/pull/956): Apply `ClassMethods` check only on `class`/`module` bodies. ([@bbatsov][])
* [#945](https://github.com/bbatsov/rubocop/issues/945): Fix SpaceBeforeFirstArg cop for multiline argument and exclude assignments. ([@cschramm][])
* [#948](https://github.com/bbatsov/rubocop/issues/948): `Blocks` cop avoids auto-correction if it would introduce a semantic change. ([@jonas054][])
* [#946](https://github.com/bbatsov/rubocop/issues/946): Allow non-nil checks that are the final expressions of predicate method definitions in `NonNilCheck`. ([@bbatsov][])
* [#957](https://github.com/bbatsov/rubocop/issues/957): Allow space + comment inside parentheses, braces, and square brackets. ([@jonas054][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
rubocop-0.48.1+dfsg.orig/relnotes/v0.21.0.md 0000664 0000000 0000000 00000011325 13070542236 0020220 0 ustar 00root root 0000000 0000000 This release brings a few new cops and extended auto-correction support. The most significant
change is that we've changed the syntax for excluding/including to be closer to that of shell globbing.
Below is the list of all the gory details. Enjoy!
### New features
* [#835](https://github.com/bbatsov/rubocop/issues/835): New cop `UnneededCapitalW` checks for `%W` when interpolation not necessary and `%w` would do. ([@sfeldon][])
* [#934](https://github.com/bbatsov/rubocop/issues/934): New cop `UnderscorePrefixedVariableName` checks for `_`-prefixed variables that are actually used. ([@yujinakayama][])
* [#934](https://github.com/bbatsov/rubocop/issues/934): New cop `UnusedMethodArgument` checks for unused method arguments. ([@yujinakayama][])
* [#934](https://github.com/bbatsov/rubocop/issues/934): New cop `UnusedBlockArgument` checks for unused block arguments. ([@yujinakayama][])
* [#964](https://github.com/bbatsov/rubocop/issues/964): `RedundantBegin` cop does auto-correction. ([@tamird][])
* [#966](https://github.com/bbatsov/rubocop/issues/966): `RescueException` cop does auto-correction. ([@tamird][])
* [#967](https://github.com/bbatsov/rubocop/issues/967): `TrivialAccessors` cop does auto-correction. ([@tamird][])
* [#963](https://github.com/bbatsov/rubocop/issues/963): Add `AllowDSLWriters` options to `TrivialAccessors`. ([@tamird][])
* [#969](https://github.com/bbatsov/rubocop/issues/969): Let the `Debugger` cop check for forgotten calls to byebug. ([@bquorning][])
* [#971](https://github.com/bbatsov/rubocop/issues/971): Configuration format deprecation warnings include the path to the problematic config file. ([@bcobb][])
* [#490](https://github.com/bbatsov/rubocop/issues/490): Add EnforcedStyle config option to TrailingBlankLines. ([@jonas054][])
* Add `auto_correct` task to Rake integration. ([@irrationalfab][])
* [#986](https://github.com/bbatsov/rubocop/issues/986): The `--only` option can take a comma-separated list of cops. ([@jonas054][])
* New Rails cop `Delegate` that checks for delegations that could be replaced by the `delegate` method. ([@geniou][])
* Add configuration to `Encoding` cop to only enforce encoding comment if there are non ASCII characters. ([@geniou][])
### Changes
* Removed `FinalNewline` cop as its check is now performed by `TrailingBlankLines`. ([@jonas054][])
* [#1011](https://github.com/bbatsov/rubocop/issues/1011): Pattern matching with `Dir#[]` for config parameters added. ([@jonas054][])
### Bugs fixed
* Update description on `LineEndConcatenation` cop. ([@mockdeep][])
* [#978](https://github.com/bbatsov/rubocop/issues/978): Fix regression in `IndentationWidth` handling method calls. ([@tamird][])
* [#976](https://github.com/bbatsov/rubocop/issues/976): Fix `EndAlignment` not handling element assignment correctly. ([@tamird][])
* [#976](https://github.com/bbatsov/rubocop/issues/976): Fix `IndentationWidth` not handling element assignment correctly. ([@tamird][])
* [#800](https://github.com/bbatsov/rubocop/issues/800): Do not report `[Corrected]` in `--auto-correct` mode if correction wasn't done. ([@jonas054][])
* [#968](https://github.com/bbatsov/rubocop/issues/968): Fix bug when running RuboCop with `-c .rubocop.yml`. ([@bquorning][])
* [#975](https://github.com/bbatsov/rubocop/pull/975): Fix infinite correction in `IndentationWidth`. ([@jonas054][])
* [#986](https://github.com/bbatsov/rubocop/issues/986): When `--lint` is used together with `--only`, all lint cops are run in addition to the given cops. ([@jonas054][])
* [#997](https://github.com/bbatsov/rubocop/issues/997): Fix handling of file paths for matching against `Exclude` property when `rubocop .` is called. ([@jonas054][])
* [#1000](https://github.com/bbatsov/rubocop/issues/1000): Support modifier (e.g., `private`) and `def` on the same line (Ruby >= 2.1) in `IndentationWidth`. ([@jonas054][])
* [#1001](https://github.com/bbatsov/rubocop/issues/1001): Fix `--auto-gen-config` logic for `RegexpLiteral`. ([@jonas054][])
* [#993](https://github.com/bbatsov/rubocop/issues/993): Do not report any offenses for the contents of an empty file. ([@jonas054][])
* [#1016](https://github.com/bbatsov/rubocop/issues/1016): Fix a false positive in `ConditionPosition` regarding statement modifiers. ([@bbatsov][])
* [#1014](https://github.com/bbatsov/rubocop/issues/1014): Fix handling of strings nested in `dstr` nodes. ([@bbatsov][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@geniou]: https://github.com/geniou
[@mockdeep]: https://github.com/mockdeep
[@tamird]: https://github.com/tamird
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@sfeldon]: https://github.com/sfeldon
rubocop-0.48.1+dfsg.orig/relnotes/v0.22.0.md 0000664 0000000 0000000 00000011601 13070542236 0020216 0 ustar 00root root 0000000 0000000 This release brings a few new cops, extended auto-correction support and plenty of bug fixes.
Below is the list of all the gory details. Enjoy!
### New features
* [#974](https://github.com/bbatsov/rubocop/pull/974): New cop `CommentIndentation` checks indentation of comments. ([@jonas054][])
* Add new cop `EachWithObject` to prefer `each_with_object` over `inject` or `reduce`. ([@geniou][])
* [#1010](https://github.com/bbatsov/rubocop/issues/1010): New Cop `Next` check for conditions at the end of an interation and propose to use `next` instead. ([@geniou][])
* The `GuardClause` cop now also looks for unless and it is configurable how many lines the body of an if / unless needs to have to not be ignored. ([@geniou][])
* [#835](https://github.com/bbatsov/rubocop/issues/835): New cop `UnneededPercentX` checks for `%x` when backquotes would do. ([@jonas054][])
* Add auto-correct to `UnusedBlockArgument` and `UnusedMethodArgument` cops. ([@hannestyden][])
* [#1074](https://github.com/bbatsov/rubocop/issues/1074): New cop `SpaceBeforeComment` checks for missing space between code and a comment on the same line. ([@jonas054][])
* [#1089](https://github.com/bbatsov/rubocop/pull/1089): New option `-F`/`--fail-fast` inspects files in modification time order and stop after the first file with offenses. ([@jonas054][])
### Changes
* `NonNilCheck` offense reporting and autocorrect are configurable to include semantic changes. ([@hannestyden][])
* The parameters `AllCops/Excludes` and `AllCops/Includes` with final `s` only give a warning and don't halt `rubocop` execution. ([@jonas054][])
* The `GuardClause` cop is no longer irgnoring a one-line body by default - see configuration. ([@geniou][])
* [#1050](https://github.com/bbatsov/rubocop/issues/1050): Rename `rubocop-todo.yml` file to `.rubocop_todo.yml`. ([@geniou][])
* [#1064](https://github.com/bbatsov/rubocop/issues/1064): Adjust default max line length to 80. ([@bbatsov][])
### Bugs fixed
* Allow assignment in `AlignParameters` cop. ([@tommeier][])
* Fix `Void` and `SpaceAroundOperators` for short call syntax `lambda.()`. ([@biinari][])
* Fix `Delegate` for delegation with assignment or constant. ([@geniou][])
* [#1032](https://github.com/bbatsov/rubocop/issues/1032): Avoid duplicate reporting when code moves around due to `--auto-correct`. ([@jonas054][])
* [#1036](https://github.com/bbatsov/rubocop/issues/1036): Handle strings like `__FILE__` in `LineEndConcatenation`. ([@bbatsov][])
* [#1006](https://github.com/bbatsov/rubocop/issues/1006): Fix LineEndConcatenation to handle chained concatenations. ([@barunio][])
* [#1066](https://github.com/bbatsov/rubocop/issues/1066): Fix auto-correct for `NegatedIf` when the condition has parentheses around it. ([@jonas054][])
* Fix `AlignParameters` `with_fixed_indentation` for multi-line method calls. ([@molawson][])
* Fix problem that appears in some installations when reading empty YAML files. ([@jonas054][])
* [#1022](https://github.com/bbatsov/rubocop/issues/1022): A Cop will no longer auto-correct a file that's excluded through an `Exclude` setting in the cop's configuration. ([@jonas054][])
* Fix paths in `Exclude` config section not being recognized on Windows. ([@wndhydrnt][])
* [#1094](https://github.com/bbatsov/rubocop/issues/1094): Fix ClassAndModuleChildren for classes with a single method. ([@geniou][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
rubocop-0.48.1+dfsg.orig/relnotes/v0.23.0.md 0000664 0000000 0000000 00000011371 13070542236 0020223 0 ustar 00root root 0000000 0000000 This release is mostly about fixing bugs, but it also features a few prominent changes:
* Cops are now namespace aware, which would it make it simpler to write RuboCop extensions without
worrying about name collisions (e.g. you can now have `Style/Filename` and `RSpec/Filename` cops).
* There's now logic which prevents auto-corrections from generated invalid Ruby code.
* The `Rubocop` module was renamed to `RuboCop`, which will affect packages relying on RuboCop's public API.
Below is the list of all the gory details. Enjoy!
### New features
* [#1117](https://github.com/bbatsov/rubocop/issues/1117): `BlockComments` cop does auto-correction. ([@jonas054][])
* [#1124](https://github.com/bbatsov/rubocop/pull/1124): `TrivialAccessors` cop auto-corrects class-level accessors. ([@ggilder][])
* [#1062](https://github.com/bbatsov/rubocop/pull/1062): New cop `InlineComment` checks for inline comments. ([@salbertson][])
* [#1118](https://github.com/bbatsov/rubocop/issues/1118): Add checking and auto-correction of right brackets in `IndentArray` and `IndentHash`. ([@jonas054][])
### Changes
* [#1097](https://github.com/bbatsov/rubocop/issues/1097): Add optional namespace prefix to cop names: `Style/LineLength` instead of `LineLength` in config files, `--only` argument, `--show-cops` output, and `# rubocop:disable`. ([@jonas054][])
* [#1075](https://github.com/bbatsov/rubocop/issues/1075): More strict limits on when to require trailing comma. ([@jonas054][])
* Renamed `Rubocop` module to `RuboCop`. ([@bbatsov][])
### Bugs fixed
* [#1126](https://github.com/bbatsov/rubocop/pull/1126): Fix `--auto-gen-config` bug with `RegexpLiteral` where only the last file's results would be used. ([@ggilder][])
* [#1104](https://github.com/bbatsov/rubocop/issues/1104): Fix `EachWithObject` with modifier if as body. ([@geniou][])
* [#1106](https://github.com/bbatsov/rubocop/issues/1106): Fix `EachWithObject` with single method call as body. ([@geniou][])
* Avoid the warning about ignoring syck YAML engine from JRuby. ([@jonas054][])
* [#1111](https://github.com/bbatsov/rubocop/issues/1111): Fix problem in `EndOfLine` with reading non-UTF-8 encoded files. ([@jonas054][])
* [#1115](https://github.com/bbatsov/rubocop/issues/1115): Fix `Next` to ignore super nodes. ([@geniou][])
* [#1117](https://github.com/bbatsov/rubocop/issues/1117): Don't auto-correct indentation in scopes that contain block comments (`=begin`..`=end`). ([@jonas054][])
* [#1123](https://github.com/bbatsov/rubocop/pull/1123): Support setter calls in safe assignment in `ParenthesesAroundCondition`. ([@jonas054][])
* [#1090](https://github.com/bbatsov/rubocop/issues/1090): Correct handling of documentation vs annotation comment. ([@jonas054][])
* [#1118](https://github.com/bbatsov/rubocop/issues/1118): Never write invalid ruby to a file in auto-correct. ([@jonas054][])
* [#1120](https://github.com/bbatsov/rubocop/issues/1120): Don't change indentation of heredoc strings in auto-correct. ([@jonas054][])
* [#1109](https://github.com/bbatsov/rubocop/issues/1109): Handle conditions with modifier ops in them in `ParenthesesAroundCondition`. ([@bbatsov][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
rubocop-0.48.1+dfsg.orig/relnotes/v0.24.0.md 0000664 0000000 0000000 00000011671 13070542236 0020227 0 ustar 00root root 0000000 0000000 This release is mostly about fixing bugs, but it also features a few new cops.
Below is the list of all the gory details. Enjoy!
### New features
* [#639](https://github.com/bbatsov/rubocop/issues/639): Support square bracket setters in `UselessSetterCall`. ([@yujinakayama][])
* [#835](https://github.com/bbatsov/rubocop/issues/835): `UnneededCapitalW` cop does auto-correction. ([@sfeldon][])
* [#1092](https://github.com/bbatsov/rubocop/issues/1092): New cop `DefEndAlignment` takes over responsibility for checkng alignment of method definition `end`s from `EndAlignment`, and is configurable. ([@jonas054][])
* [#1145](https://github.com/bbatsov/rubocop/issues/1145): New cop `ClassCheck` enforces consistent use of `is_a?` or `kind_of?`. ([@bbatsov][])
* [#1161](https://github.com/bbatsov/rubocop/pull/1161): New cop `SpaceBeforeComma` detects spaces before a comma. ([@agrimm][])
* [#1161](https://github.com/bbatsov/rubocop/pull/1161): New cop `SpaceBeforeSemicolon` detects spaces before a semicolon. ([@agrimm][])
* [#835](https://github.com/bbatsov/rubocop/issues/835): New cop `UnneededPercentQ` checks for usage of the `%q`/`%Q` syntax when `''` or `""` would do. ([@jonas054][])
* [#977](https://github.com/bbatsov/rubocop/issues/977): Add `AllowURI` option (enabled by default) to `LineLength` cop. ([@yujinakayama][])
### Changes
* Unused block local variables (`obj.each { |arg; this| }`) are now handled by `UnusedBlockArgument` cop instead of `UselessAssignment` cop. ([@yujinakayama][])
* [#1141](https://github.com/bbatsov/rubocop/issues/1141): Clarify in the message from `TrailingComma` that a trailing comma is never allowed for lists where some items share a line. ([@jonas054][])
### Bugs fixed
* [#1133](https://github.com/bbatsov/rubocop/issues/1133): Handle `reduce/inject` with no arguments in `EachWithObject`. ([@bbatsov][])
* [#1152](https://github.com/bbatsov/rubocop/issues/1152): Handle `while/until` with no body in `Next`. ([@tamird][])
* Fix a false positive in `UselessSetterCall` for setter call on a local variable that contains a non-local object. ([@yujinakayama][])
* [#1158](https://github.com/bbatsov/rubocop/issues/1158): Fix auto-correction of floating-point numbers. ([@bbatsov][])
* [#1159](https://github.com/bbatsov/rubocop/issues/1159): Fix checking of `begin`..`end` structures, blocks, and parenthesized expressions in `IndentationWidth`. ([@jonas054][])
* [#1159](https://github.com/bbatsov/rubocop/issues/1159): More rigid conditions for when `attr` is considered an offense. ([@jonas054][])
* [#1167](https://github.com/bbatsov/rubocop/issues/1167): Fix handling of parameters spanning multiple lines in `TrailingComma`. ([@jonas054][])
* [#1169](https://github.com/bbatsov/rubocop/issues/1169): Fix handling of ternary op conditions in `ParenthesesAroundCondition`. ([@bbatsov][])
* [#1147](https://github.com/bbatsov/rubocop/issues/1147): WordArray checks arrays with special characters. ([@camilleldn][])
* Fix a false positive against `return` in a loop in `Next` cop. ([@yujinakayama][])
* [#1165](https://github.com/bbatsov/rubocop/issues/1165): Support `rescue`/`else`/`ensure` bodies in `IndentationWidth`. ([@jonas054][])
* Fix false positive for aligned list of values after `when` in `IndentationWidth`. ([@jonas054][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
rubocop-0.48.1+dfsg.orig/relnotes/v0.24.1.md 0000664 0000000 0000000 00000002160 13070542236 0020221 0 ustar 00root root 0000000 0000000 RuboCop 0.24.1 is a bugfix-only release. Below is a list of the bugs we've fixed since 0.24.0:
## 0.24.1 (03/07/2014)
### Bugs fixed
* [#1174](https://github.com/bbatsov/rubocop/issues/1174): Fix `--auto-correct` crash in `AlignParameters`. ([@jonas054][])
* [#1176](https://github.com/bbatsov/rubocop/issues/1176): Fix `--auto-correct` crash in `IndentationWidth`. ([@jonas054][])
* [#1177](https://github.com/bbatsov/rubocop/issues/1177): Avoid suggesting underscore-prefixed name for unused keyword arguments and auto-correcting in that way. ([@yujinakayama][])
* [#1157](https://github.com/bbatsov/rubocop/issues/1157): Validate `--only` arguments later when all cop names are known. ([@jonas054][])
* [#1188](https://github.com/bbatsov/rubocop/issues/1188), [#1190](https://github.com/bbatsov/rubocop/issues/1190): Fix crash in `LineLength` cop when `AllowURI` option is enabled. ([@yujinakayama][])
* [#1191](https://github.com/bbatsov/rubocop/issues/1191): Fix crash on empty body branches in a loop in `Next` cop. ([@yujinakayama][])
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
rubocop-0.48.1+dfsg.orig/relnotes/v0.25.0.md 0000664 0000000 0000000 00000013772 13070542236 0020234 0 ustar 00root root 0000000 0000000 This release comes with lots of bug fixes and several new cops (that will likely need bugfixes in the next release :-)).
The most notable change in 0.25 is the addition of the `Metrics` namespace. Several `Style` cops have been moved there
(e.g. `ClassLength`, `MethodLength`, etc).
This release also marks the end of us supporting Ruby 1.9.2 - now Ruby 1.9.3+ is required.
Below is the list of all the gory details. Enjoy!
### New features
* [#1259](https://github.com/bbatsov/rubocop/issues/1259): Allow AndOr cop to autocorrect by adding method call parenthesis. ([@vrthra][])
* [#1232](https://github.com/bbatsov/rubocop/issues/1232): Add EnforcedStyle option to cop `AndOr` to restrict it to conditionals. ([@vrthra][])
* [#835](https://github.com/bbatsov/rubocop/issues/835): New cop `PercentQLiterals` checks if use of `%Q` and `%q` matches configuration. ([@jonas054][])
* [#835](https://github.com/bbatsov/rubocop/issues/835): New cop `BarePercentLiterals` checks if usage of `%()` or `%Q()` matches configuration. ([@jonas054][])
* [#1079](https://github.com/bbatsov/rubocop/pull/1079): New cop `MultilineBlockLayout` checks if a multiline block has an extpression on the same line as the start of the block. ([@barunio][])
* [#1217](https://github.com/bbatsov/rubocop/pull/1217): `Style::EmptyLinesAroundAccessModifier` cop does auto-correction. ([@tamird][])
* [#1220](https://github.com/bbatsov/rubocop/issues/1220): New cop `PerceivedComplexity` is similar to `CyclomaticComplexity`, but reports when methods have a high complexity for a human reader. ([@jonas054][])
* `Debugger` cop now checks for `binding.pry_remote`. ([@yous][])
* [#1238](https://github.com/bbatsov/rubocop/issues/1238): Add `MinBodyLength` option to `Next` cop. ([@bbatsov][])
* [#1241](https://github.com/bbatsov/rubocop/issues/1241): `TrailingComma` cop does auto-correction. ([@yous][])
* [#1078](https://github.com/bbatsov/rubocop/pull/1078): New cop `BlockEndNewline` checks if the end statement of a multiline block is on its own line. ([@barunio][])
* [#1078](https://github.com/bbatsov/rubocop/pull/1078): `BlockAlignment` cop does auto-correction. ([@barunio][])
### Changes
* [#1220](https://github.com/bbatsov/rubocop/issues/1220): New namespace `Metrics` created and some `Style` cops moved there. ([@jonas054][])
* Drop support for Ruby 1.9.2 in accordance with [the end of the security maintenance extension](https://www.ruby-lang.org/en/news/2014/07/01/eol-for-1-8-7-and-1-9-2/). ([@yujinakayama][])
### Bugs fixed
* [#1251](https://github.com/bbatsov/rubocop/issues/1251): Fix `PercentLiteralDelimiters` auto-correct indentation error. ([@hannestyden][])
* [#1197](https://github.com/bbatsov/rubocop/issues/1197): Fix false positive for new lambda syntax in `SpaceInsideBlockBraces`. ([@jonas054][])
* [#1201](https://github.com/bbatsov/rubocop/issues/1201): Fix error at anonymous keyword splat arguments in some variable cops. ([@yujinakayama][])
* Fix false positive in `UnneededPercentQ` for `/%Q(something)/`. ([@jonas054][])
* Fix `SpacesInsideBrackets` for `Hash#[]` calls with spaces after left bracket. ([@mcls][])
* [#1210](https://github.com/bbatsov/rubocop/issues/1210): Fix false positive in `UnneededPercentQ` for `%Q(\t")`. ([@jonas054][])
* Fix false positive in `UnneededPercentQ` for heredoc strings with `%q`/`%Q`. ([@jonas054][])
* [#1214](https://github.com/bbatsov/rubocop/issues/1214): Don't destroy code in `AlignHash` autocorrect. ([@jonas054][])
* [#1219](https://github.com/bbatsov/rubocop/issues/1219): Don't report bad alignment for `end` or `}` in `BlockAlignment` if it doesn't begin its line. ([@jonas054][])
* [#1227](https://github.com/bbatsov/rubocop/issues/1227): Don't permanently change yamler as it can affect other apps. ([@jonas054][])
* [#1184](https://github.com/bbatsov/rubocop/issues/1184): Fix a false positive in `Output` cop. ([@bbatsov][])
* [#1256](https://github.com/bbatsov/rubocop/issues/1256): Ignore block-pass in `TrailingComma`. ([@tamird][])
* [#1255](https://github.com/bbatsov/rubocop/issues/1255): Compare without context in `AutocorrectUnlessChangingAST`. ([@jonas054][])
* [#1262](https://github.com/bbatsov/rubocop/issues/1262): Handle regexp and backtick literals in `VariableInterpolation`. ([@bbatsov][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
rubocop-0.48.1+dfsg.orig/relnotes/v0.26.0.md 0000664 0000000 0000000 00000012732 13070542236 0020230 0 ustar 00root root 0000000 0000000 Nothing particularly exciting this time around. The new release comes
with lots of bug fixes, more auto-corrections and several new cops.
Note that the `Style/Encoding` cop is now disabled by default. See
[#1304](https://github.com/bbatsov/rubocop/issues/1304) for the
rationale behind this change.
Below is the list of all the gory details. Enjoy!
### New features
* New formatter `HTMLFormatter` generates a html file with a list of files with offences in them. ([@SkuliOskarsson][])
* New cop `SpaceInsideRangeLiteral` checks for spaces around `..` and `...` in range literals. ([@bbatsov][])
* New cop `InfiniteLoop` checks for places where `Kernel#loop` should have been used. ([@bbatsov][])
* New cop `SymbolProc` checks for places where a symbol can be used as proc instead of a block. ([@bbatsov][])
* `UselessAssignment` cop now suggests a variable name for possible typos if there's a variable-ish identifier similar to the unused variable name in the same scope. ([@yujinakayama][])
* `PredicateName` cop now has separate configurations for prefices that denote predicate method names and predicate prefices that should be removed. ([@bbatsov][])
* [#1272](https://github.com/bbatsov/rubocop/issues/1272): `Tab` cop does auto-correction. ([@yous][])
* [#1274](https://github.com/bbatsov/rubocop/issues/1274): `MultilineIfThen` cop does auto-correction. ([@bbatsov][])
* [#1279](https://github.com/bbatsov/rubocop/issues/1279): `DotPosition` cop does auto-correction. ([@yous][])
* [#1277](https://github.com/bbatsov/rubocop/issues/1277): `SpaceBeforeFirstArg` cop does auto-correction. ([@yous][])
* [#1310](https://github.com/bbatsov/rubocop/issues/1310): Handle `module_function` in `Style/AccessModifierIndentation` and `Style/EmptyLinesAroundAccessModifier`. ([@bbatsov][])
### Changes
* [#1289](https://github.com/bbatsov/rubocop/issues/1289): Use utf-8 as default encoding for inspected files. ([@jonas054][])
* [#1304](https://github.com/bbatsov/rubocop/issues/1304): `Style/Encoding` is no longer a no-op on Ruby 2.x. It's also disabled by default, as projects not supporting 1.9 don't need to run it. ([@bbatsov][])
### Bugs fixed
* [#1263](https://github.com/bbatsov/rubocop/issues/1263): Do not report `%W` literals with special escaped characters in `UnneededCapitalW`. ([@jonas054][])
* [#1286](https://github.com/bbatsov/rubocop/issues/1286): Fix a false positive in `VariableName`. ([@bbatsov][])
* [#1211](https://github.com/bbatsov/rubocop/issues/1211): Fix false negative in `UselessAssignment` when there's a reference for the variable in an exclusive branch. ([@yujinakayama][])
* [#1307](https://github.com/bbatsov/rubocop/issues/1307): Fix auto-correction of `RedundantBegin` cop deletes new line. ([@yous][])
* [#1283](https://github.com/bbatsov/rubocop/issues/1283): Fix auto-correction of indented expressions in `PercentLiteralDelimiters`. ([@jonas054][])
* [#1315](https://github.com/bbatsov/rubocop/pull/1315): `BracesAroundHashParameters` auto-correction removes whitespace around content inside braces. ([@jspanjers][])
* [#1313](https://github.com/bbatsov/rubocop/issues/1313): Fix a false positive in `AndOr` when enforced style is `conditionals`. ([@bbatsov][])
* Handle post-conditional `while` and `until` in `AndOr` when enforced style is `conditionals`. ([@yujinakayama][])
* [#1319](https://github.com/bbatsov/rubocop/issues/1319): Fix a false positive in `FormatString`. ([@bbatsov][])
* [#1287](https://github.com/bbatsov/rubocop/issues/1287): Allow missing blank line for EmptyLinesAroundAccessModifier if next line closes a block. ([@sch1zo][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
rubocop-0.48.1+dfsg.orig/relnotes/v0.26.1.md 0000664 0000000 0000000 00000001541 13070542236 0020225 0 ustar 00root root 0000000 0000000 RuboCop 0.26.1 is a bugfix-only release. Below is a list of the bugs we've fixed since 0.26.0:
### Bugs fixed
* [#1326](https://github.com/bbatsov/rubocop/issues/1326): Fix problem in `SpaceInsideParens` with detecting space inside parentheses used for grouping expressions. ([@jonas054][])
* [#1335](https://github.com/bbatsov/rubocop/issues/1335): Restrict URI schemes permitted by `LineLength` when `AllowURI` is enabled. ([@smangelsdorf][])
* [#1339](https://github.com/bbatsov/rubocop/issues/1339): Handle `eql?` and `equal?` in `OpMethod`. ([@bbatsov][])
* [#1340](https://github.com/bbatsov/rubocop/issues/1340): Fix crash in `Style/SymbolProc` cop when the block calls a method with no explicit receiver. ([@smangelsdorf][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@smangelsdorf]: https://github.com/smangelsdorf
rubocop-0.48.1+dfsg.orig/relnotes/v0.27.0.md 0000664 0000000 0000000 00000011133 13070542236 0020223 0 ustar 00root root 0000000 0000000 ### New features
* [#1348](https://github.com/bbatsov/rubocop/issues/1348): New cop `ElseAlignment` checks alignment of `else` and `elsif` keywords. ([@jonas054][])
* [#1321](https://github.com/bbatsov/rubocop/issues/1321): New cop `MultilineOperationIndentation` checks indentation/alignment of binary operations if they span more than one line. ([@jonas054][])
* [#1077](https://github.com/bbatsov/rubocop/issues/1077): New cop `Metrics/AbcSize` checks the ABC metric, based on assignments, branches, and conditions. ([@jonas054][], [@jfelchner][])
* [#1352](https://github.com/bbatsov/rubocop/issues/1352): `WordArray` is now configurable with the `WordRegex` option. ([@bquorning][])
* [#1181](https://github.com/bbatsov/rubocop/issues/1181): New cop `Style/StringLiteralsInInterpolation` checks quotes inside interpolated expressions in strings. ([@jonas054][])
* [#872](https://github.com/bbatsov/rubocop/issues/872): `Style/IndentationWidth` is now configurable with the `Width` option. ([@jonas054][])
* [#1396](https://github.com/bbatsov/rubocop/issues/1396): Include `.opal` files by default. ([@bbatsov][])
* [#771](https://github.com/bbatsov/rubocop/issues/771): Three new `Style` cops, `EmptyLinesAroundMethodBody` , `EmptyLinesAroundClassBody` , and `EmptyLinesAroundModuleBody` replace the `EmptyLinesAroundBody` cop. ([@jonas054][])
### Changes
* [#1084](https://github.com/bbatsov/rubocop/issues/1084): Disabled `Style/CollectionMethods` by default. ([@bbatsov][])
### Bugs fixed
* `AlignHash` no longer skips multiline hashes that contain some elements on the same line. ([@mvz][])
* [#1349](https://github.com/bbatsov/rubocop/issues/1349): `BracesAroundHashParameters` no longer cleans up whitespace in autocorrect, as these extra corrections are likely to interfere with other cops' corrections. ([@jonas054][])
* [#1350](https://github.com/bbatsov/rubocop/issues/1350): Guard against `Blocks` cop introducing syntax errors in auto-correct. ([@jonas054][])
* [#1374](https://github.com/bbatsov/rubocop/issues/1374): To eliminate interference, auto-correction is now done by one cop at a time, with saving and re-parsing inbetween. ([@jonas054][])
* [#1388](https://github.com/bbatsov/rubocop/issues/1388): Fix a false positive in `FormatString`. ([@bbatsov][])
* [#1389](https://github.com/bbatsov/rubocop/issues/1389): Make `--out` to create parent directories. ([@yous][])
* Refine HTML formatter. ([@yujinakayama][])
* [#1410](https://github.com/bbatsov/rubocop/issues/1410): Handle specially Java primitive type references in `ColonMethodCall`. ([@bbatsov][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
rubocop-0.48.1+dfsg.orig/relnotes/v0.27.1.md 0000664 0000000 0000000 00000006644 13070542236 0020237 0 ustar 00root root 0000000 0000000 ### Changes
* [#1343](https://github.com/bbatsov/rubocop/issues/1343): Remove auto-correct from `RescueException` cop. ([@bbatsov][])
* [#1425](https://github.com/bbatsov/rubocop/issues/1425): `AllCops/Include` configuration parameters are only taken from the project `.rubocop.yml` and files it inherits from, not from `.rubocop.yml` files in subdirectories. ([@jonas054][])
### Bugs fixed
* [#1411](https://github.com/bbatsov/rubocop/issues/1411): Handle lambda calls without a selector in `MultilineOperationIndentation`. ([@bbatsov][])
* [#1401](https://github.com/bbatsov/rubocop/issues/1401): Files in hidden directories, i.e. ones beginning with dot, can now be selected through configuration, but are still not included by default. ([@jonas054][])
* [#1415](https://github.com/bbatsov/rubocop/issues/1415): String literals concatenated with backslashes are now handled correctly by `StringLiteralsInInterpolation`. ([@jonas054][])
* [#1416](https://github.com/bbatsov/rubocop/issues/1416): Fix handling of `begin/rescue/else/end` in `ElseAlignment`. ([@jonas054][])
* [#1413](https://github.com/bbatsov/rubocop/issues/1413): Support empty elsif branches in `MultilineIfThen`. ([@janraasch][], [@jonas054][])
* [#1406](https://github.com/bbatsov/rubocop/issues/1406): Allow a newline in `SpaceInsideRangeLiteral`. ([@bbatsov][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
rubocop-0.48.1+dfsg.orig/relnotes/v0.28.0.md 0000664 0000000 0000000 00000013263 13070542236 0020232 0 ustar 00root root 0000000 0000000 ### New features
* New cop `ExtraSpacing` points out unnecessary spacing in files. ([@blainesch][])
* New cop `EmptyLinesAroundBlockBody` provides same functionality as the EmptyLinesAround(Class|Method|Module)Body but for blocks. ([@jcarbo][])
* New cop `Style/EmptyElse` checks for empty `else`-clauses. ([@Koronen][])
* [#1454](https://github.com/bbatsov/rubocop/issues/1454): New `--only-guide-cops` and `AllCops/StyleGuideCopsOnly` options that will only enforce cops that link to a style guide. ([@marxarelli][])
### Changes
* [#801](https://github.com/bbatsov/rubocop/issues/801): New style `context_dependent` for `Style/BracesAroundHashParameters` looks at preceding parameter to determine if braces should be used for final parameter. ([@jonas054][])
* [#1427](https://github.com/bbatsov/rubocop/issues/1427): Excluding directories on the top level is now done earlier, so that these file trees are not searched, thus saving time when inspecting projects with many excluded files. ([@jonas054][])
* [#1325](https://github.com/bbatsov/rubocop/issues/1325): When running with `--auto-correct`, only offenses *that can not be corrected* will result in a non-zero exit code. ([@jonas054][])
* [#1445](https://github.com/bbatsov/rubocop/issues/1445): Allow sprockets directive comments (starting with `#=`) in `Style/LeadingCommentSpace`. ([@bbatsov][])
### Bugs fixed
* Fix `%W[]` auto corrected to `%w(]`. ([@toy][])
* Fix Style/ElseAlignment Cop to find the right parent on def/rescue/else/ensure/end. ([@oneamtu][])
* [#1181](https://github.com/bbatsov/rubocop/issues/1181): *(fix again)* `Style/StringLiterals` cop stays away from strings inside interpolated expressions. ([@jonas054][])
* [#1441](https://github.com/bbatsov/rubocop/issues/1441): Correct the logic used by `Style/Blocks` and other cops to determine if an auto-correction would alter the meaning of the code. ([@jonas054][])
* [#1449](https://github.com/bbatsov/rubocop/issues/1449): Handle the case in `MultilineOperationIndentation` where instances of both correct style and unrecognized (plain wrong) style are detected during an `--auto-gen-config` run. ([@jonas054][])
* [#1456](https://github.com/bbatsov/rubocop/pull/1456): Fix autocorrect in `SymbolProc` when there are multiple offenses on the same line. ([@jcarbo][])
* [#1459](https://github.com/bbatsov/rubocop/issues/1459): Handle parenthesis around the condition in `--auto-correct` for `NegatedWhile`. ([@jonas054][])
* [#1465](https://github.com/bbatsov/rubocop/issues/1465): Fix autocorrect of code like `#$1` in `PerlBackrefs`. ([@bbatsov][])
* Fix autocorrect of code like `#$:` in `SpecialGlobalVars`. ([@bbatsov][])
* [#1466](https://github.com/bbatsov/rubocop/issues/1466): Allow leading underscore for unused parameters in `SingleLineBlockParams`. ([@jonas054][])
* [#1470](https://github.com/bbatsov/rubocop/issues/1470): Handle `elsif` + `else` in `ElseAlignment`. ([@jonas054][])
* [#1474](https://github.com/bbatsov/rubocop/issues/1474): Multiline string with both `<<` and `\` caught by `Style/LineEndConcatenation` cop. ([@katieschilling][])
* [#1485](https://github.com/bbatsov/rubocop/issues/1485): Ignore procs in `SymbolProc`. ([@bbatsov][])
* [#1473](https://github.com/bbatsov/rubocop/issues/1473): `Style/MultilineOperationIndentation` doesn't recognize assignment to array/hash element. ([@jonas054][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
rubocop-0.48.1+dfsg.orig/relnotes/v0.29.0.md 0000664 0000000 0000000 00000020411 13070542236 0020224 0 ustar 00root root 0000000 0000000 ### New features
* [#1430](https://github.com/bbatsov/rubocop/issues/1430): Add `--except` option for disabling cops on the command line. ([@jonas054][])
* [#1506](https://github.com/bbatsov/rubocop/pull/1506): Add auto-correct from `EvenOdd` cop. ([@blainesch][])
* [#1507](https://github.com/bbatsov/rubocop/issues/1507): `Debugger` cop now checks for the Capybara debug methods `save_and_open_page` and `save_and_open_screenshot`. ([@rrosenblum][])
* [#1539](https://github.com/bbatsov/rubocop/pull/1539): Implement autocorrection for Rails/ReadWriteAttribute cop. ([@huerlisi][])
* [#1324](https://github.com/bbatsov/rubocop/issues/1324): Add `AllCops/DisplayCopNames` configuration option for showing cop names in reports, like `--display-cop-names`. ([@jonas054][])
* [#1271](https://github.com/bbatsov/rubocop/issues/1271): `Lambda` cop does auto-correction. ([@lumeet][])
* [#1284](https://github.com/bbatsov/rubocop/issues/1284): Support namespaces, e.g. `Lint`, in the arguments to `--only` and `--except`. ([@jonas054][])
* [#1276](https://github.com/bbatsov/rubocop/issues/1276): `SelfAssignment` cop does auto-correction. ([@lumeet][])
* Add autocorrect to `RedundantException`. ([@mattjmcnaughton][])
* [#1571](https://github.com/bbatsov/rubocop/pull/1571): New cop `StructInheritance` checks for inheritance from Struct.new. ([@mmozuras][])
* [#1575](https://github.com/bbatsov/rubocop/issues/1575): New cop `DuplicateMethods` points out duplicate method name in class and module. ([@d4rk5eed][])
* [#1144](https://github.com/bbatsov/rubocop/issues/1144): New cop `FirstParameterIndentation` checks the indentation of the first parameter in a method call. ([@jonas054][])
* [#1627](https://github.com/bbatsov/rubocop/issues/1627): New cop `SpaceAroundBlockParameters` checks the spacing inside and after block parameters pipes. ([@jonas054][])
### Changes
* [#1492](https://github.com/bbatsov/rubocop/pull/1492): Abort when auto-correct causes an infinite loop. ([@dblock][])
* Options `-e`/`--emacs` and `-s`/`--silent` are no longer recognized. Using them will now raise an error. ([@bquorning][])
* [#1565](https://github.com/bbatsov/rubocop/issues/1565): Let `--fail-level A` cause exit with error if all offenses are auto-corrected. ([@jonas054][])
* [#1309](https://github.com/bbatsov/rubocop/issues/1309): Add argument handling to `MultilineBlockLayout`. ([@lumeet][])
### Bugs fixed
* [#1634](https://github.com/bbatsov/rubocop/pull/1634): Fix `PerlBackrefs` Cop Autocorrections to Not Raise. ([@cshaffer][])
* [#1553](https://github.com/bbatsov/rubocop/pull/1553): Fix bug where `Style/EmptyLinesAroundAccessModifier` interfered with `Style/EmptyLinesAroundBlockBody` when there is and access modifier at the beginning of a block. ([@volkert][])
* Handle element assignment in `Lint/AssignmentInCondition`. ([@jonas054][])
* [#1484](https://github.com/bbatsov/rubocop/issues/1484): Fix `EmptyLinesAroundAccessModifier` incorrectly finding a violation inside method calls with names identical to an access modifier. ([@dblock][])
* Fix bug concerning `Exclude` properties inherited from a higher directory level. ([@jonas054][])
* [#1500](https://github.com/bbatsov/rubocop/issues/1500): Fix crashing `--auto-correct --only IndentationWidth`. ([@jonas054][])
* [#1512](https://github.com/bbatsov/rubocop/issues/1512): Fix false negative for typical string formatting examples. ([@kakutani][], [@jonas054][])
* [#1504](https://github.com/bbatsov/rubocop/issues/1504): Fail with a meaningful error if the configuration file is malformed. ([@bquorning][])
* Fix bug where `auto_correct` Rake tasks does not take in the options specified in its parent task. ([@rrosenblum][])
* [#1054](https://github.com/bbatsov/rubocop/issues/1054): Handle comments within concatenated strings in `LineEndConcatenation`. ([@yujinakayama][], [@jonas054][])
* [#1527](https://github.com/bbatsov/rubocop/issues/1527): Make autocorrect `BracesAroundHashParameter` leave the correct number of spaces. ([@mattjmcnaughton][])
* [#1547](https://github.com/bbatsov/rubocop/issues/1547): Don't print `[Corrected]` when auto-correction was avoided in `Style/Semicolon`. ([@jonas054][])
* [#1573](https://github.com/bbatsov/rubocop/issues/1573): Fix assignment-related auto-correction for `BlockAlignment`. ([@lumeet][])
* [#1587](https://github.com/bbatsov/rubocop/pull/1587): Exit with exit code 1 if there were errors ("crashing" cops). ([@jonas054][])
* [#1574](https://github.com/bbatsov/rubocop/issues/1574): Avoid auto-correcting `Hash.new` to `{}` when braces would be interpreted as a block. ([@jonas054][])
* [#1591](https://github.com/bbatsov/rubocop/issues/1591): Don't check parameters inside `[]` in `MultilineOperationIndentation`. ([@jonas054][])
* [#1509](https://github.com/bbatsov/rubocop/issues/1509): Ignore class methods in `Rails/Delegate`. ([@bbatsov][])
* [#1594](https://github.com/bbatsov/rubocop/issues/1594): Fix `@example` warnings in Yard Doc documentation generation. ([@mattjmcnaughton][])
* [#1598](https://github.com/bbatsov/rubocop/issues/1598): Fix bug in file inclusion when running from another directory. ([@jonas054][])
* [#1580](https://github.com/bbatsov/rubocop/issues/1580): Don't print `[Corrected]` when auto-correction was avoided in `TrivialAccessors`. ([@lumeet][])
* [#1612](https://github.com/bbatsov/rubocop/issues/1612): Allow `expand_path` on `inherit_from` in `.rubocop.yml`. ([@mattjmcnaughton][])
* [#1610](https://github.com/bbatsov/rubocop/issues/1610): Check that class method names actually match the name of the containing class/module in `Style/ClassMethods`. ([@bbatsov][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
rubocop-0.48.1+dfsg.orig/relnotes/v0.29.1.md 0000664 0000000 0000000 00000001624 13070542236 0020232 0 ustar 00root root 0000000 0000000 ### Bugs fixed
* [#1638](https://github.com/bbatsov/rubocop/issues/1638): Use Parser functionality rather than regular expressions for matching comments in `FirstParameterIndentation`. ([@jonas054][])
* [#1642](https://github.com/bbatsov/rubocop/issues/1642): Raise the correct exception if the configuration file is malformed. ([@bquorning][])
* [#1647](https://github.com/bbatsov/rubocop/issues/1647): Skip `SpaceAroundBlockParameters` when lambda has no argument. ([@eitoball][])
* [#1649](https://github.com/bbatsov/rubocop/issues/1649): Handle exception assignments in `UselessSetterCall`. ([@bbatsov][])
* [#1644](https://github.com/bbatsov/rubocop/issues/1644): Don't search the entire file system when a folder is named `,`. ([@bquorning][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@bquorning]: https://github.com/bquorning
[@eitoball]: https://github.com/eitoball
rubocop-0.48.1+dfsg.orig/relnotes/v0.30.0.md 0000664 0000000 0000000 00000024731 13070542236 0020225 0 ustar 00root root 0000000 0000000 Nothing ground-breaking this time around, but the release is pretty exciting non-the-less.
It packs a whole new category of cops (`Performance`) and a bunch of new Rails cops.
A lot of the existing cops got new customization options and we squashed a ton of bugs.
Thanks to everyone who contributed to this release!
### New features
* [#1600](https://github.com/bbatsov/rubocop/issues/1600): Add `line_count_based` and `semantic` styles to the `BlockDelimiters` (formerly `Blocks`) cop. ([@clowder][], [@mudge][])
* [#1712](https://github.com/bbatsov/rubocop/pull/1712): Set `Offense#corrected?` to `true`, `false`, or `nil` when it was, wasn't, or can't be auto-corrected, respectively. ([@vassilevsky][])
* [#1669](https://github.com/bbatsov/rubocop/pull/1669): Add command-line switch `--display-style-guide`. ([@marxarelli][])
* [#1405](https://github.com/bbatsov/rubocop/issues/1405): Add Rails TimeZone and Date cops. ([@palkan][])
* [#1641](https://github.com/bbatsov/rubocop/pull/1641): Add ruby19_no_mixed_keys style to `HashStyle` cop. ([@iainbeeston][])
* [#1604](https://github.com/bbatsov/rubocop/issues/1604): Add `IgnoreClassMethods` option to `TrivialAccessors` cop. ([@bbatsov][])
* [#1651](https://github.com/bbatsov/rubocop/issues/1651): The `Style/SpaceAroundOperators` cop now also detects extra spaces around operators. A list of operators that *may* be surrounded by multiple spaces is configurable. ([@bquorning][])
* Add auto-correct to `Encoding` cop. ([@rrosenblum][])
* [#1621](https://github.com/bbatsov/rubocop/issues/1621): `TrailingComma` has a new style `consistent_comma`. ([@tamird][])
* [#1611](https://github.com/bbatsov/rubocop/issues/1611): Add `empty`, `nil`, and `both` `SupportedStyles` to `EmptyElse` cop. Default is `both`. ([@rrosenblum][])
* [#1611](https://github.com/bbatsov/rubocop/issues/1611): Add new `MissingElse` cop. Default is to have this cop be disabled. ([@rrosenblum][])
* [#1602](https://github.com/bbatsov/rubocop/issues/1602): Add support for `# :nodoc` in `Documentation`. ([@lumeet][])
* [#1437](https://github.com/bbatsov/rubocop/issues/1437): Modify `HashSyntax` cop to allow the use of hash rockets for hashes that have symbol values when using ruby19 syntax. ([@rrosenblum][])
* New cop `Style/SymbolLiteral` makes sure you're not using the string within symbol syntax unless it's needed. ([@bbatsov][])
* [#1657](https://github.com/bbatsov/rubocop/issues/1657): Autocorrect can be turned off on a specific cop via the configuration. ([@jdoconnor][])
* New cop `Style/AutoResourceCleanup` suggests the use of block taking versions of methods that do resource cleanup. ([@bbatsov][])
* [#1275](https://github.com/bbatsov/rubocop/issues/1275): `WhileUntilModifier` cop does auto-correction. ([@lumeet][])
* New cop `Performance/ReverseEach` to convert `reverse.each` to `reverse_each`. ([@rrosenblum][])
* [#1281](https://github.com/bbatsov/rubocop/issues/1281): `IfUnlessModifier` cop does auto-correction. ([@lumeet][])
* New cop `Performance/Detect` to detect usage of `select.first`, `select.last`, `find_all.first`, and `find_all.last` and convert them to use `detect` instead. ([@palkan][], [@rrosenblum][])
* [#1728](https://github.com/bbatsov/rubocop/pull/1728): New cop `NonLocalExitFromIterator` checks for misused `return` in block. ([@ypresto][])
* New cop `Performance/Size` to convert calls to `count` on `Array` and `Hash` to `size`. ([@rrosenblum][])
* New cop `Performance/Sample` to convert usages of `shuffle.first`, `shuffle.last`, and `shuffle[Integer]` to `sample`. ([@rrosenblum][])
* New cop `Performance/FlatMap` to convert `Enumerable#map...Array#flatten` and `Enumerable#collect...Array#flatten` to `Enumerable#flat_map`. ([@rrosenblum][])
* [#1144](https://github.com/bbatsov/rubocop/issues/1144): New cop `ClosingParenthesisIndentation` checks the indentation of hanging closing parentheses. ([@jonas054][])
* New Rails cop `FindBy` identifies usages of `where.first` and `where.take`. ([@bbatsov][])
* New Rails cop `FindEach` identifies usages of `all.each`. ([@bbatsov][])
* [#1342](https://github.com/bbatsov/rubocop/issues/1342): `IndentationConsistency` is now configurable with the styles `normal` and `rails`. ([@jonas054][])
### Bugs fixed
* [#1705](https://github.com/bbatsov/rubocop/issues/1705): Fix crash when reporting offenses of `MissingElse` cop. ([@gerry3][])
* [#1659](https://github.com/bbatsov/rubocop/pull/1659): Fix stack overflow with JRuby and Windows 8, during initial config validation. ([@pimterry][])
* [#1694](https://github.com/bbatsov/rubocop/issues/1694): Ignore methods with a `blockarg` in `TrivialAccessors`. ([@bbatsov][])
* [#1617](https://github.com/bbatsov/rubocop/issues/1617): Always read the html output template using utf-8. ([@bbatsov][])
* [#1684](https://github.com/bbatsov/rubocop/issues/1684): Ignore symbol keys like `:"string"` in `HashSyntax`. ([@bbatsov][])
* Handle explicit `begin` blocks in `Lint/Void`. ([@bbatsov][])
* Handle symbols in `Lint/Void`. ([@bbatsov][])
* [#1695](https://github.com/bbatsov/rubocop/pull/1695): Fix bug with `--auto-gen-config` and `SpaceInsideBlockBraces`. ([@meganemura][])
* Correct issues with whitespace around multi-line lambda arguments. ([@zvkemp][])
* [#1579](https://github.com/bbatsov/rubocop/issues/1579): Fix handling of similar-looking blocks in `BlockAlignment`. ([@lumeet][])
* [#1676](https://github.com/bbatsov/rubocop/pull/1676): Fix auto-correct in `Lambda` when a new multi-line lambda is used as an argument. ([@lumeet][])
* [#1656](https://github.com/bbatsov/rubocop/issues/1656): Fix bug that would include hidden directories implicitly. ([@jonas054][])
* [#1728](https://github.com/bbatsov/rubocop/pull/1728): Fix bug in `LiteralInInterpolation` and `AssignmentInCondition`. ([@ypresto][])
* [#1735](https://github.com/bbatsov/rubocop/issues/1735): Handle trailing space in `LineEndConcatenation` autocorrect. ([@jonas054][])
* [#1750](https://github.com/bbatsov/rubocop/issues/1750): Escape offending code lines output by the HTML formatter in case they contain markup. ([@jonas054][])
* [#1541](https://github.com/bbatsov/rubocop/issues/1541): No inspection of text that follows `__END__`. ([@jonas054][])
* Fix comment detection in `Style/Documentation`. ([@lumeet][])
* [#1637](https://github.com/bbatsov/rubocop/issues/1637): Fix handling of `binding` calls in `UnusedBlockArgument` and `UnusedMethodArgument`. ([@lumeet][])
### Changes
* [#1397](https://github.com/bbatsov/rubocop/issues/1397): `UnneededPercentX` renamed to `CommandLiteral`. The cop can be configured to enforce using either `%x` or backticks around command literals, or using `%x` around multi-line commands and backticks around single-line commands. The cop ignores heredoc commands. ([@bquorning][])
* [#1020](https://github.com/bbatsov/rubocop/issues/1020): Removed the `MaxSlashes` configuration option for `RegexpLiteral`. Instead, the cop can be configured to enforce using either `%r` or slashes around regular expressions, or using `%r` around multi-line regexes and slashes around single-line regexes. ([@bquorning][])
* [#1734](https://github.com/bbatsov/rubocop/issues/1734): The default exclusion of hidden directories has been optimized for speed. ([@jonas054][])
* [#1673](https://github.com/bbatsov/rubocop/issues/1673): `Style/TrivialAccessors` now requires matching names by default. ([@bbatsov][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
rubocop-0.48.1+dfsg.orig/relnotes/v0.30.1.md 0000664 0000000 0000000 00000013023 13070542236 0020216 0 ustar 00root root 0000000 0000000 Enjoy all those bug-fixes!
### Bugs fixed
* [#1691](https://github.com/bbatsov/rubocop/issues/1691): For assignments with line break after `=`, use `keyword` alignment in `EndAlignment` regardless of configured style. ([@jonas054][])
* [#1769](https://github.com/bbatsov/rubocop/issues/1769): Fix bug where `LiteralInInterpolation` registers an offense for interpolation of `__LINE__`. ([@rrosenblum][])
* [#1773](https://github.com/bbatsov/rubocop/pull/1773): Fix typo ('strptime' -> 'strftime') in `Rails/TimeZone`. ([@palkan][])
* [#1777](https://github.com/bbatsov/rubocop/pull/1777): Fix offense message from Rails/TimeZone. ([@mzp][])
* [#1784](https://github.com/bbatsov/rubocop/pull/1784): Add an explicit error message when config contains an empty section. ([@bankair][])
* [#1791](https://github.com/bbatsov/rubocop/pull/1791): Fix autocorrection of `PercentLiteralDelimiters` with no content. ([@cshaffer][])
* Fix handling of `while` and `until` with assignment in `IndentationWidth`. ([@lumeet][])
* [#1793](https://github.com/bbatsov/rubocop/pull/1793): Fix bug in `TrailingComma` that caused `,` in comment to count as a trailing comma. ([@jonas054][])
* [#1765](https://github.com/bbatsov/rubocop/pull/1765): Update 1.9 hash to stop triggering when the symbol is not valid in the 1.9 hash syntax. ([@crimsonknave][])
* [#1806](https://github.com/bbatsov/rubocop/issues/1806): Require a newer version of `parser` and use its corrected solution for comment association in `Style/Documentation`. ([@jonas054][])
* [#1792](https://github.com/bbatsov/rubocop/issues/1792): Fix bugs in `Sample` that did not account for array selectors with a range and passing random to shuffle. ([@rrosenblum][])
* [#1770](https://github.com/bbatsov/rubocop/pull/1770): Add more acceptable methods to `Rails/TimeZone` (`utc`, `localtime`, `to_i`, `iso8601` etc). ([@palkan][])
* [#1767](https://github.com/bbatsov/rubocop/pull/1767): Do not register offenses on non-enumerable select/find_all by `Performance/Detect`. ([@palkan][])
* [#1795](https://github.com/bbatsov/rubocop/pull/1795): Fix bug in `TrailingBlankLines` that caused a crash for files containing only newlines. ([@renuo][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
rubocop-0.48.1+dfsg.orig/relnotes/v0.31.0.md 0000664 0000000 0000000 00000015656 13070542236 0020234 0 ustar 00root root 0000000 0000000 ### New features
* `Rails/TimeZone` emits acceptable methods on a violation when `EnforcedStyle` is `:acceptable`. ([@l8nite][])
* Recognize rackup file (config.ru) out of the box. ([@carhartl][])
* [#1788](https://github.com/bbatsov/rubocop/pull/1788): New cop `ModuleLength` checks for overly long module definitions. ([@sdeframond][])
* New cop `Performance/Count` to convert `Enumerable#select...size`, `Enumerable#reject...size`, `Enumerable#select...count`, `Enumerable#reject...count` `Enumerable#select...length`, and `Enumerable#reject...length` to `Enumerable#count`. ([@rrosenblum][])
* `CommentAnnotation` cop does auto-correction. ([@dylandavidson][])
* New cop `Style/TrailingUnderscoreVariable` to remove trailing underscore variables from mass assignment. ([@rrosenblum][])
* [#1136](https://github.com/bbatsov/rubocop/issues/1136): New cop `Performance/ParallelAssignment` to avoid usages of unnessary parallel assignment. ([@rrosenblum][])
* [#1278](https://github.com/bbatsov/rubocop/issues/1278): `DefEndAlignment` and `EndAlignment` cops do auto-correction. ([@lumeet][])
* `IndentationWidth` cop follows the `AlignWith` option of the `DefEndAlignment` cop. ([@lumeet][])
* [#1837](https://github.com/bbatsov/rubocop/issues/1837): New cop `EachWithObjectArgument` checks that `each_with_object` isn't called with an immutable object as argument. ([@jonas054][])
* `ArrayJoin` cop does auto-correction. ([@tmr08c][])
### Bugs fixed
* [#1816](https://github.com/bbatsov/rubocop/issues/1816): Fix bug in `Sample` when calling `#shuffle` with something other than an element selector. ([@rrosenblum][])
* [#1768](https://github.com/bbatsov/rubocop/pull/1768): `DefEndAlignment` recognizes preceding `private_class_method` or `public_class_method` before `def`. ([@til][])
* [#1820](https://github.com/bbatsov/rubocop/issues/1820): Correct the logic in `AlignHash` for when to ignore a key because it's not on its own line. ([@jonas054][])
* [#1829](https://github.com/bbatsov/rubocop/pull/1829): Fix bug in `Sample` and `FlatMap` that would cause them to report having been auto-corrected when they were not. ([@rrosenblum][])
* [#1832](https://github.com/bbatsov/rubocop/pull/1832): Fix bug in `UnusedMethodArgument` that would cause them to report having been auto-corrected when they were not. ([@jonas054][])
* [#1834](https://github.com/bbatsov/rubocop/issues/1834): Support only boolean values for `AutoCorrect` configuration parameter, and remove warning for unknown parameter. ([@jonas054][])
* [#1843](https://github.com/bbatsov/rubocop/issues/1843): Fix crash in `TrailingBlankLines` when a file ends with a block comment without final newline. ([@jonas054][])
* [#1849](https://github.com/bbatsov/rubocop/issues/1849): Fix bug where you can not have nested arrays in the Rake task configuration. ([@rrosenblum][])
* Fix bug in `MultilineTernaryOperator` where it will not register an offense when only the false branch is on a separate line. ([@rrosenblum][])
* Fix crash in `MultilineBlockLayout` when using new lambda literal syntax without parentheses. ([@hbd225][])
* [#1859](https://github.com/bbatsov/rubocop/pull/1859): Fix bugs in `IfUnlessModifier` concerning comments and empty lines. ([@jonas054][])
* Fix handling of trailing comma in `SpaceAroundBlockParameters` and `SpaceAfterComma`. ([@lumeet][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
rubocop-0.48.1+dfsg.orig/relnotes/v0.32.0.md 0000664 0000000 0000000 00000017762 13070542236 0020235 0 ustar 00root root 0000000 0000000 ### New features
* Adjust behavior of `TrailingComma` cop to account for multi-line hashes nested within method calls. ([@panthomakos][])
* [#1719](https://github.com/bbatsov/rubocop/pull/1719): Display an error and abort the program if input file can't be found. ([@matugm][])
* New cop `SpaceInsideStringInterpolation` checks for spaces within string interpolations. ([@glasnt][])
* New cop `NestedMethodDefinition` checks for method definitions inside other methods. ([@ojab][])
* `LiteralInInterpolation` cop does auto-correction. ([@tmr08c][])
* [#1865](https://github.com/bbatsov/rubocop/issues/1865): New cop `Lint/UnneededDisable` checks for `rubocop:disable` comments that can be removed. ([@jonas054][])
* `EmptyElse` cop does auto-correction. ([@lumeet][])
* Show reference links when displaying style guide links. ([@rrosenblum][])
* `Debugger` cop now checks for the Capybara debug method `save_screenshot`. ([@crazydog115][])
* [#1282](https://github.com/bbatsov/rubocop/issues/1282): `CaseIndentation` cop does auto-correction. ([@lumeet][])
* [#1928](https://github.com/bbatsov/rubocop/issues/1928): Do auto-correction one offense at a time (rather than one cop at a time) if there are tabs in the code. ([@jonas054][])
### Changes
* Prefer `SpaceInsideBlockBraces` to `SpaceBeforeSemicolon` and `SpaceAfterSemicolon` to avoid an infinite loop when auto-correcting. ([@lumeet][])
* [#1873](https://github.com/bbatsov/rubocop/issues/1873): Move `ParallelAssignment` cop from Performance to Style. ([@rrosenblum][])
* Add `getlocal` to acceptable methods of `Rails/TimeZone`. ([@ojab][])
* [#1851](https://github.com/bbatsov/rubocop/issues/1851), [#1948](https://github.com/bbatsov/rubocop/issues/1948): Change offense message for `ClassLength` and `ModuleLength` to match that of `MethodLength`. ([@bquorning][])
### Bugs fixed
* Don't count required keyword args when specifying `CountKeywordArgs: false` for `ParameterLists`. ([@sumeet][])
* [#1879](https://github.com/bbatsov/rubocop/issues/1879): Avoid auto-correcting hash with trailing comma into invalid code in `BracesAroundHashParameters`. ([@jonas054][])
* [#1868](https://github.com/bbatsov/rubocop/issues/1868): Do not register an offense in `Performance/Count` when `select` is called with symbols or strings as the parameters. ([@rrosenblum][])
* `Sample` rewritten to properly handle shuffle randomness source, first/last params and non-literal ranges. ([@chastell][])
* [#1873](https://github.com/bbatsov/rubocop/issues/1873): Modify `ParallelAssignment` to properly autocorrect when the assignment is protected by a modifier statement. ([@rrosenblum][])
* Configure `ParallelAssignment` to work with non-standard `IndentationWidths`. ([@rrosenblum][])
* [#1899](https://github.com/bbatsov/rubocop/issues/1899): Be careful about comments when auto-correcting in `BracesAroundHashParameters`. ([@jonas054][])
* [#1897](https://github.com/bbatsov/rubocop/issues/1897): Don't report that semicolon separated statements can be converted to modifier form in `IfUnlessModifier` (and don't auto-correct them). ([@jonas054][])
* [#1644](https://github.com/bbatsov/rubocop/issues/1644): Don't search the entire file system when a folder is named `,` (fix for jruby and rbx). ([@rrosenblum][])
* [#1803](https://github.com/bbatsov/rubocop/issues/1803): Don't warn for `return` from `lambda` block in `NonLocalExitFromIterator`. ([@ypresto][])
* [#1905](https://github.com/bbatsov/rubocop/issues/1905): Ignore sparse and trailing comments in `Style/Documentation`. ([@RGBD][])
* [#1923](https://github.com/bbatsov/rubocop/issues/1923): Handle properly `for` without body in `Style/Next`. ([@bbatsov][])
* [#1901](https://github.com/bbatsov/rubocop/issues/1901): Do not auto correct comments that are missing a note. ([@rrosenblum][])
* [#1926](https://github.com/bbatsov/rubocop/issues/1926): Fix crash in `Style/AlignHash` when correcting a hash with a splat in it. ([@rrosenblum][])
* [#1935](https://github.com/bbatsov/rubocop/issues/1935): Allow `Symbol#to_proc` blocks in Performance/Size. ([@m1foley][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
rubocop-0.48.1+dfsg.orig/relnotes/v0.32.1.md 0000664 0000000 0000000 00000013014 13070542236 0020220 0 ustar 00root root 0000000 0000000 ### New features
* `Debugger` cop now checks catches methods called with arguments. ([@crazydog115][])
### Bugs fixed
* Make it possible to disable `Lint/UnneededDisable`. ([@jonas054][])
* [#1958](https://github.com/bbatsov/rubocop/issues/1958): Show name of `Lint/UnneededDisable` when `-D/--display-cop-names` is given. ([@jonas054][])
* Do not show `Style/NonNilCheck` offenses as corrected when the source code is not modified. ([@rrosenblum][])
* Fix auto-correct in `Style/RedundantReturn` when `return` has no arguments. ([@lumeet][])
* [#1955](https://github.com/bbatsov/rubocop/issues/1955): Fix false positive for `Style/TrailingComma` cop. ([@mattjmcnaughton][])
* [#1928](https://github.com/bbatsov/rubocop/issues/1928): Avoid auto-correcting two alignment offenses in the same area at the same time. ([@jonas054][])
* [#1964](https://github.com/bbatsov/rubocop/issues/1964): Fix `RedundantBegin` auto-correct issue with comments by doing a smaller correction. ([@jonas054][])
* [#1978](https://github.com/bbatsov/rubocop/pull/1978): Don't count disabled offences if fail-level is autocorrect. ([@sch1zo][])
* [#1986](https://github.com/bbatsov/rubocop/pull/1986): Fix Date false positives on variables. ([@palkan][])
### Changes
* [#1708](https://github.com/bbatsov/rubocop/issues/1708): Improve message for `FirstParameterIndentation`. ([@tejasbubane][])
* [#1959](https://github.com/bbatsov/rubocop/issues/1959): Allow `Lint/UnneededDisable` to be inline disabled. ([@rrosenblum][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
[@tejasbubane]: https://github.com/tejasbubane
rubocop-0.48.1+dfsg.orig/relnotes/v0.33.0.md 0000664 0000000 0000000 00000024362 13070542236 0020230 0 ustar 00root root 0000000 0000000 ### New features
* [#2081](https://github.com/bbatsov/rubocop/pull/2081): New cop `Style/Send` checks for the use of `send` and instead encourages changing it to `BasicObject#__send__` or `Object#public_send` (disabled by default). ([@syndbg][])
* [#2057](https://github.com/bbatsov/rubocop/pull/2057): New cop `Lint/FormatParameterMismatch` checks for a mismatch between the number of fields expected in format/sprintf/% and what was pased to it. ([@edmz][])
* [#2010](https://github.com/bbatsov/rubocop/pull/2010): Add `space` style for SpaceInsideStringInterpolation. ([@gotrevor][])
* [#2007](https://github.com/bbatsov/rubocop/pull/2007): Allow any modifier before `def`, not only visibility modifiers. ([@fphilipe][])
* [#1980](https://github.com/bbatsov/rubocop/pull/1980): `--auto-gen-config` now outputs an excluded files list for failed cops (up to a maxiumum of 15 files). ([@bmorrall][])
* [#2004](https://github.com/bbatsov/rubocop/pull/2004): Introduced `--exclude-limit COUNT` to configure how many files `--auto-gen-config` will exclude. ([@awwaiid][], [@jonas054][])
* [#1918](https://github.com/bbatsov/rubocop/issues/1918): New configuration parameter `AllCops:DisabledByDefault` when set to `true` makes only cops found in user configuration enabled, which makes cop selection *opt-in*. ([@jonas054][])
* New cop `Performance/StringReplacement` checks for usages of `gsub` that can be replaced with `tr` or `delete`. ([@rrosenblum][])
* [#2001](https://github.com/bbatsov/rubocop/issues/2001): New cop `Style/InitialIndentation` checks for indentation of the first non-blank non-comment line in a file. ([@jonas054][])
* [#2060](https://github.com/bbatsov/rubocop/issues/2060): New cop `Style/RescueEnsureAlignment` checks for bad alignment of `rescue` and `ensure` keywords. ([@lumeet][])
* New cop `Style/OptionalArguments` checks for optional arguments that do not appear at the end of an argument list. ([@rrosenblum][])
* New cop `Lint/CircularArgumentReference` checks for "circular argument references" in keyword arguments, which Ruby 2.2 warns against. ([@maxjacobson][], [@sliuu][])
* [#2030](https://github.com/bbatsov/rubocop/issues/2030): New cop `Style/OptionHash` checks for option hashes and encourages changing them to keyword arguments (disabled by default). ([@maxjacobson][])
### Changes
* [#2052](https://github.com/bbatsov/rubocop/pull/2052): `Style/RescueModifier` uses token stream to identify offenses. ([@urbanautomaton][])
* Rename `Rails/Date` and `Rails/TimeZone` style names to "strict" and "flexible" and make "flexible" to be default. ([@palkan][])
* [#2035](https://github.com/bbatsov/rubocop/issues/2035): `Style/ExtraSpacing` is now enabled by default and has a configuration parameter `AllowForAlignment` that is `true` by default, making it allow extra spacing if it's used for alignment purposes. ([@jonas054][])
### Bugs fixed
* [#2014](https://github.com/bbatsov/rubocop/pull/2014): Fix `Style/TrivialAccessors` to support AllowPredicates: false. ([@gotrevor][])
* [#1988](https://github.com/bbatsov/rubocop/issues/1988): Fix bug in `Style/ParallelAssignment` when assigning from `Module::CONSTANT`. ([@rrosenblum][])
* [#1995](https://github.com/bbatsov/rubocop/pull/1995): Improve message for `Rails/TimeZone`. ([@palkan][])
* [#1977](https://github.com/bbatsov/rubocop/issues/1977): Fix bugs in `Rails/Date` and `Rails/TimeZone` when using namespaced Time/Date. ([@palkan][])
* [#1973](https://github.com/bbatsov/rubocop/issues/1973): Do not register an offense in `Performance/Detect` when `select` is called on `Enumerable::Lazy`. ([@palkan][])
* [#2015](https://github.com/bbatsov/rubocop/issues/2015): Fix bug occurring for auto-correction of a misaligned `end` in a file with only one method. ([@jonas054][])
* Allow string interpolation segments inside single quoted string literals when double quotes are preferred. ([@segiddins][])
* [#2026](https://github.com/bbatsov/rubocop/issues/2026): Allow `Time.current` when style is "acceptable".([@palkan][])
* [#2029](https://github.com/bbatsov/rubocop/issues/2029): Fix bug where `Style/RedundantReturn` auto-corrects returning implicit hashes to invalid syntax. ([@rrosenblum][])
* [#2021](https://github.com/bbatsov/rubocop/issues/2021): Fix bug in `Style/BlockDelimiters` when a `semantic` expression is used in an array or a range. ([@lumeet][])
* [#1992](https://github.com/bbatsov/rubocop/issues/1992): Allow parentheses in assignment to a variable with the same name as the method's in `Style/MethodCallParentheses`. ([@lumeet][])
* [#2045](https://github.com/bbatsov/rubocop/issues/2045): Fix crash in `Style/IndentationWidth` when using `private_class_method def self.foo` syntax. ([@unmanbearpig][])
* [#2006](https://github.com/bbatsov/rubocop/issues/2006): Fix crash in `Style/FirstParameterIndentation` in case of nested offenses. ([@unmanbearpig][])
* [#2059](https://github.com/bbatsov/rubocop/issues/2059): Don't check for trivial accessors in modules. ([@bbatsov][])
* Add proper punctuation to the end of offense messages, where it is missing. ([@lumeet][])
* [#2071](https://github.com/bbatsov/rubocop/pull/2071): Keep line breaks in place on WordArray autocorrect.([@unmanbearpig][])
* [#2075](https://github.com/bbatsov/rubocop/pull/2075): Properly correct `Style/PercentLiteralDelimiters` with escape characters in them. ([@rrosenblum][])
* [#2023](https://github.com/bbatsov/rubocop/issues/2023): Avoid auto-correction corruption in `IndentationWidth`. ([@jonas054][])
* [#2080](https://github.com/bbatsov/rubocop/issues/2080): Properly parse code in `Performance/Count` when calling `select..count` in a class that extends an enumerable. ([@rrosenblum][])
* [#2093](https://github.com/bbatsov/rubocop/issues/2093): Fix bug in `Style/OneLineConditional` which should not raise an offense with an 'if/then/end' statement. ([@sliuu][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
[@tejasbubane]: https://github.com/tejasbubane
[@bmorrall]: https://github.com/bmorrall
[@fphilipe]: https://github.com/fphilipe
[@gotrevor]: https://github.com/gotrevor
[@awwaiid]: https://github.com/awwaiid
[@segiddins]: https://github.com/segiddins
[@urbanautomaton]: https://github.com/urbanautomaton.com
[@unmanbearpig]: https://github.com/unmanbearpig
[@maxjacobson]: https://github.com/maxjacobson
[@sliuu]: https://github.com/sliuu
[@edmz]: https://github.com/edmz
[@syndbg]: https://github.com/syndbg
rubocop-0.48.1+dfsg.orig/relnotes/v0.34.0.md 0000664 0000000 0000000 00000026270 13070542236 0020231 0 ustar 00root root 0000000 0000000 Apart from the usual myriad of bugfixes, improvements and new cops,
this version introduces a results caching functionality. This
functionality will speed up tremendously consecutive RuboCop runs on
the same codebase.
Another news to share with you - the project now has a crowdfunding
campaign [here](https://salt.bountysource.com/teams/rubocop). If you like RuboCop
you might consider supporting its development.
Enjoy!
### New features
* [#2143](https://github.com/bbatsov/rubocop/pull/2143): New cop `Performance/CaseWhenSplat` will identify and rearange `case` `when` statements that contain a `when` condition with a splat. ([@rrosenblum][])
* New cop `Lint/DuplicatedKey` checks for duplicated keys in hashes, which Ruby 2.2 warns against. ([@sliuu][])
* [#2106](https://github.com/bbatsov/rubocop/issues/2106): Add `SuspiciousParamNames` option to `Style/OptionHash`. ([@wli][])
* [#2193](https://github.com/bbatsov/rubocop/pull/2193): `Style/Next` supports more `Enumerable` methods. ([@rrosenblum][])
* [#2179](https://github.com/bbatsov/rubocop/issues/2179): Add `--list-target-files` option to CLI, which prints the files which will be inspected. ([@maxjacobson][])
* New cop `Style/MutableConstant` checks for assignment of mutable objects to constants. ([@bbatsov][])
* New cop `Style/RedudantFreeze` checks for usages of `Object#freeze` on immutable objects. ([@bbatsov][])
* [#1924](https://github.com/bbatsov/rubocop/issues/1924): New option `--cache` and configuration parameter `AllCops: UseCache` turn result caching on (default) or off. ([@jonas054][])
* [#2204](https://github.com/bbatsov/rubocop/pull/2204): New cop `Style/StringMethods` will check for preferred method `to_sym` over `intern`. ([@imtayadeway][])
### Changes
* [#1351](https://github.com/bbatsov/rubocop/issues/1351): Allow class emitter methods in `Style/MethodName`. ([@jonas054][])
* [#2126](https://github.com/bbatsov/rubocop/pull/2126): `Style/RescueModifier` can now auto-correct. ([@rrosenblum][])
* [#2109](https://github.com/bbatsov/rubocop/issues/2109): Allow alignment with a token on the nearest line with same indentation in `Style/ExtraSpacing`. ([@jonas054][])
* `Lint/EndAlignment` handles the `case` keyword. ([@lumeet][])
* [#2146](https://github.com/bbatsov/rubocop/pull/2146): Add STDIN support. ([@caseywebdev][])
* [#2175](https://github.com/bbatsov/rubocop/pull/2175): Files that are excluded from a cop (e.g. using the `Exclude:` config option) are no longer being processed by that cop. ([@bquorning][])
* `Rails/ActionFilter` now handles complete list of methods found in the Rails 4.2 [release notes](https://github.com/rails/rails/blob/4115a12da1409c753c747fd4bab6e612c0c6e51a/guides/source/4_2_release_notes.md#notable-changes-1). ([@MGerrior][])
* [*2138](https://github.com/bbatsov/rubocop/issues/2138): Change the offense in `Style/Next` to highlight the condition instead of the iteration. ([@rrosenblum][])
* `Style/EmptyLineBetweenDefs` now handles class methods as well. ([@unmanbearpig][])
* Improve handling of `super` in `Style/SymbolProc`. ([@lumeet][])
* `Style/SymbolProc` is applied to methods receiving arguments. ([@lumeet][])
* [#1839](https://github.com/bbatsov/rubocop/issues/1839): Remove Rainbow monkey patching of String which conflicts with other gems like colorize. ([@daviddavis][])
* `Style/HashSyntax` is now a bit faster when checking Ruby 1.9 syntax hash keys. ([@bquorning][])
* `Lint/DeprecatedClassMethods` is now a whole lot faster. ([@bquorning][])
* `Lint/BlockAlignment`, `Style/IndentationWidth`, and `Style/MultilineOperationIndentation` are now quite a bit faster. ([@bquorning][])
### Bug Fixes
* [#2123](https://github.com/bbatsov/rubocop/pull/2123): Fix handing of dynamic widths `Lint/FormatParameterMismatch`. ([@edmz][])
* [#2116](https://github.com/bbatsov/rubocop/pull/2116): Fix named params (using hash) `Lint/FormatParameterMismatch`. ([@edmz][])
* [#2135](https://github.com/bbatsov/rubocop/issues/2135): Ignore `super` and `zsuper` nodes in `Style/SymbolProc`. ([@bbatsov][])
* [#2165](https://github.com/bbatsov/rubocop/issues/2165): Fix a NPE in `Style/Alias`. ([@bbatsov][])
* [#2168](https://github.com/bbatsov/rubocop/issues/2168): Fix a NPE in `Rails/TimeZone`. ([@bbatsov][])
* [#2169](https://github.com/bbatsov/rubocop/issues/2169): Fix a NPE in `Rails/Date`. ([@bbatsov][])
* [#2105](https://github.com/bbatsov/rubocop/pull/2105): Fix a warning that was thrown when enabling `Style/OptionHash`. ([@wli][])
* [#2107](https://github.com/bbatsov/rubocop/pull/2107): Fix auto-correct of `Style/ParallelAssignment` for nested expressions. ([@rrosenblum][])
* [#2111](https://github.com/bbatsov/rubocop/issues/2111): Deal with byte order mark in `Style/InitialIndentation`. ([@jonas054][])
* [#2113](https://github.com/bbatsov/rubocop/issues/2113): Handle non-string tokens in `Style/ExtraSpacing`. ([@jonas054][])
* [#2129](https://github.com/bbatsov/rubocop/issues/2129): Handle empty interpolations in `Style/SpaceInsideStringInterpolation`. ([@lumeet][])
* [#2119](https://github.com/bbatsov/rubocop/issues/2119): Do not raise an error in `Style/RescueEnsureAlignment` and `Style/RescueModifier` when processing an excluded file. ([@rrosenblum][])
* [#2149](https://github.com/bbatsov/rubocop/issues/2149): Do not register an offense in `Rails/Date` when `Date#to_time` is called with a time zone argument. ([@maxjacobson][])
* Do not register a `Rails/TimeZone` offense when using Time.new safely. ([@maxjacobson][])
* [#2124](https://github.com/bbatsov/rubocop/issues/2124): Fix bug in `Style/EmptyLineBetweenDefs` when there are only comments between method definitions. ([@lumeet][])
* [#2154](https://github.com/bbatsov/rubocop/issues/2154): `Performance/StringReplacement` can auto-correct replacements with backslash in them. ([@rrosenblum][])
* [#2009](https://github.com/bbatsov/rubocop/issues/2009): Fix bug in `RuboCop::ConfigLoader.load_file` when `safe_yaml` is required. ([@eitoball][])
* [#2155](https://github.com/bbatsov/rubocop/issues/2155): Configuration `EndAlignment: AlignWith: variable` only applies when the operands of `=` are on the same line. ([@jonas054][])
* Fix bug in `Style/IndentationWidth` when `rescue` or `ensure` is preceded by an empty body. ([@lumeet][])
* [#2183](https://github.com/bbatsov/rubocop/issues/2183): Fix bug in `Style/BlockDelimiters` when auto-correcting adjacent braces. ([@lumeet][])
* [#2199](https://github.com/bbatsov/rubocop/issues/2199): Make `rubocop` exit with error when there are only `Lint/UnneededDisable` offenses. ([@jonas054][])
* Fix handling of empty parentheses when auto-correcting in `Style/SymbolProc`. ([@lumeet][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
[@tejasbubane]: https://github.com/tejasbubane
[@bmorrall]: https://github.com/bmorrall
[@fphilipe]: https://github.com/fphilipe
[@gotrevor]: https://github.com/gotrevor
[@awwaiid]: https://github.com/awwaiid
[@segiddins]: https://github.com/segiddins
[@urbanautomaton]: https://github.com/urbanautomaton.com
[@unmanbearpig]: https://github.com/unmanbearpig
[@maxjacobson]: https://github.com/maxjacobson
[@sliuu]: https://github.com/sliuu
[@edmz]: https://github.com/edmz
[@syndbg]: https://github.com/syndbg
[@wli]: https://github.com/wli
[@caseywebdev]: https://github.com/caseywebdev
[@MGerrior]: https://github.com/MGerrior
[@imtayadeway]: https://github.com/imtayadeway
rubocop-0.48.1+dfsg.orig/relnotes/v0.34.1.md 0000664 0000000 0000000 00000013117 13070542236 0020226 0 ustar 00root root 0000000 0000000 ## RuboCop 0.34.1
### Bug Fixes
* [#2212](https://github.com/bbatsov/rubocop/issues/2212): Handle methods without parentheses in auto-correct. ([@karreiro][])
* [#2214](https://github.com/bbatsov/rubocop/pull/2214): Fix `File name too long error` when `STDIN` option is provided. ([@mrfoto][])
* [#2217](https://github.com/bbatsov/rubocop/issues/2217): Allow block arguments in `Style/SymbolProc`. ([@lumeet][])
* [#2213](https://github.com/bbatsov/rubocop/issues/2213): Write to cache with binary encoding to avoid transcoding exceptions in some locales. ([@jonas054][])
* [#2218](https://github.com/bbatsov/rubocop/issues/2218): Fix loading config error when safe yaml is only partially loaded. ([@maxjacobson][])
* [#2161](https://github.com/bbatsov/rubocop/issues/2161): Allow an explicit receiver (except `Kernel`) in `Style/SignalException`. ([@lumeet][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
[@tejasbubane]: https://github.com/tejasbubane
[@bmorrall]: https://github.com/bmorrall
[@fphilipe]: https://github.com/fphilipe
[@gotrevor]: https://github.com/gotrevor
[@awwaiid]: https://github.com/awwaiid
[@segiddins]: https://github.com/segiddins
[@urbanautomaton]: https://github.com/urbanautomaton.com
[@unmanbearpig]: https://github.com/unmanbearpig
[@maxjacobson]: https://github.com/maxjacobson
[@sliuu]: https://github.com/sliuu
[@edmz]: https://github.com/edmz
[@syndbg]: https://github.com/syndbg
[@wli]: https://github.com/wli
[@caseywebdev]: https://github.com/caseywebdev
[@MGerrior]: https://github.com/MGerrior
[@imtayadeway]: https://github.com/imtayadeway
[@mrfoto]: https://github.com/mrfoto
[@karreiro]: https://github.com/karreiro
rubocop-0.48.1+dfsg.orig/relnotes/v0.34.2.md 0000664 0000000 0000000 00000015626 13070542236 0020236 0 ustar 00root root 0000000 0000000 ### Bug Fixes
* [#2232](https://github.com/bbatsov/rubocop/issues/2232): Fix false positive in `Lint/FormatParameterMismatch` for argument with splat operator. ([@dreyks][])
* [#2237](https://github.com/bbatsov/rubocop/pull/2237): Allow `Lint/FormatParameterMismatch` to be called using `Kernel.format` and `Kernel.sprintf`. ([@rrosenblum][])
* [#2234](https://github.com/bbatsov/rubocop/issues/2234): Do not register an offense for `Lint/FormatParameterMismatch` when the format string is a variable. ([@rrosenblum][])
* [#2240](https://github.com/bbatsov/rubocop/pull/2240): `Lint/UnneededDisable` should not report non-`Lint` `rubocop:disable` comments when running `rubocop --lint`. ([@jonas054][])
* [#2121](https://github.com/bbatsov/rubocop/issues/2121): Allow space before values in hash literals in `Style/ExtraSpacing` to avoid correction conflict. ([@jonas054][])
* [#2241](https://github.com/bbatsov/rubocop/issues/2241): Read cache in binary format. ([@jonas054][])
* [#2247](https://github.com/bbatsov/rubocop/issues/2247): Fix auto-correct of `Performance/CaseWhenSplat` for percent arrays (`%w`, `%W`, `%i`, and `%I`). ([@rrosenblum][])
* [#2244](https://github.com/bbatsov/rubocop/issues/2244): Disregard annotation keywords in `Style/CommentAnnotation` if they don't start a comment. ([@jonas054][])
* [#2257](https://github.com/bbatsov/rubocop/pull/2257): Fix bug where `Style/RescueEnsureAlignment` will register an offense for `rescue` and `ensure` on the same line. ([@rrosenblum][])
* [#2255](https://github.com/bbatsov/rubocop/issues/2255): Refine the offense highlighting for `Style/SymbolProc`. ([@bbatsov][])
* [#2260](https://github.com/bbatsov/rubocop/pull/2260): Make `Exclude` in `.rubocop_todo.yml` work when running from a subdirectory. ([@jonas054][])
### Changes
* [#2248](https://github.com/bbatsov/rubocop/issues/2248): Allow block-pass in `Style/AutoResourceCleanup`. ([@lumeet][])
* [#2258](https://github.com/bbatsov/rubocop/pull/2258): `Style/Documentation` will exclude test directories by default. ([@rrosenblum][])
* [#2260](https://github.com/bbatsov/rubocop/issues/2260): Disable `Style/StringMethods` by default. ([@bbatsov][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
[@tejasbubane]: https://github.com/tejasbubane
[@bmorrall]: https://github.com/bmorrall
[@fphilipe]: https://github.com/fphilipe
[@gotrevor]: https://github.com/gotrevor
[@awwaiid]: https://github.com/awwaiid
[@segiddins]: https://github.com/segiddins
[@urbanautomaton]: https://github.com/urbanautomaton.com
[@unmanbearpig]: https://github.com/unmanbearpig
[@maxjacobson]: https://github.com/maxjacobson
[@sliuu]: https://github.com/sliuu
[@edmz]: https://github.com/edmz
[@syndbg]: https://github.com/syndbg
[@wli]: https://github.com/wli
[@caseywebdev]: https://github.com/caseywebdev
[@MGerrior]: https://github.com/MGerrior
[@imtayadeway]: https://github.com/imtayadeway
[@mrfoto]: https://github.com/mrfoto
[@karreiro]: https://github.com/karreiro
[@dreyks]: https://github.com/dreyks
rubocop-0.48.1+dfsg.orig/relnotes/v0.35.0.md 0000664 0000000 0000000 00000036533 13070542236 0020235 0 ustar 00root root 0000000 0000000 Special thanks to [Alex Dowad](https://github.com/alexdowad) who
contributed an amazing number of bug fixes and improvements for this
release! Much appreciated!
And happy birthday to my beloved granny Vasilka, who turns today 78 years!
This release is dedicated to her!
### New features
* [#2028](https://github.com/bbatsov/rubocop/issues/2028): New config `ExtraDetails` supports addition of `Details` param to all cops to allow extra details on offense to be displayed. ([@tansaku][])
* [#2036](https://github.com/bbatsov/rubocop/issues/2036): New cop `Style/StabbyLambdaParentheses` will find and correct cases where a stabby lambda's paramaters are not wrapped in parentheses. ([@hmadison][])
* [#2246](https://github.com/bbatsov/rubocop/pull/2246): `Style/TrailingUnderscoreVariable` will now register an offense for `*_`. ([@rrosenblum][])
* [#2246](https://github.com/bbatsov/rubocop/pull/2246): `Style/TrailingUnderscoreVariable` now has a configuration to remove named underscore variables (Defaulted to false). ([@rrosenblum][])
* [#2276](https://github.com/bbatsov/rubocop/pull/2276): New cop `Performance/FixedSize` will register an offense when calling `length`, `size`, or `count` on statically sized objected (strings, symbols, arrays, and hashes). ([@rrosenblum][])
* New cop `Style/NestedModifier` checks for nested `if`, `unless`, `while` and `until` modifier statements. ([@lumeet][])
* [#2270](https://github.com/bbatsov/rubocop/pull/2270): Add a new `inherit_gem` configuration to inherit a config file from an installed gem [(originally requested in #290)](https://github.com/bbatsov/rubocop/issues/290). ([@jhansche][])
* Allow `StyleGuide` parameters in local configuration for all cops, so users can add references to custom style guide documents. ([@cornelius][])
* `UnusedMethodArgument` cop allows configuration to skip keyword arguments. ([@apiology][])
* [#2318](https://github.com/bbatsov/rubocop/pull/2318): `Lint/Debugger` cop now checks for `Pry.rescue`. ([@rrosenblum][])
* [#2277](https://github.com/bbatsov/rubocop/pull/2277): New cop `Style/FirstArrayElementLineBreak` checks for a line break before the first element in a multi-line array. ([@panthomakos][])
* [#2277](https://github.com/bbatsov/rubocop/pull/2277): New cop `Style/FirstHashElementLineBreak` checks for a line break before the first element in a multi-line hash. ([@panthomakos][])
* [#2277](https://github.com/bbatsov/rubocop/pull/2277): New cop `Style/FirstMethodArgumentLineBreak` checks for a line break before the first argument in a multi-line method call. ([@panthomakos][])
* [#2277](https://github.com/bbatsov/rubocop/pull/2277): New cop `Style/FirstMethodParameterLineBreak` checks for a line break before the first parameter in a multi-line method parameter definition. ([@panthomakos][])
* Add `Rails/PluralizationGrammar` cop, checks for incorrect grammar when using methods like `3.day.ago`, when you should write `3.days.ago`. ([@maxjacobson][])
* [#2347](https://github.com/bbatsov/rubocop/pull/2347): `Lint/Eval` cop does not warn about "security risk" when eval argument is a string literal without interpolations. ([@alexdowad][])
* [#2335](https://github.com/bbatsov/rubocop/issues/2335): `Style/VariableName` cop checks naming style of method parameters. ([@alexdowad][])
* [#2329](https://github.com/bbatsov/rubocop/pull/2329): New style `braces_for_chaining` for `Style/BlockDelimiters` cop enforces braces on a multi-line block if its return value is being chained with another method. ([@panthomakos][])
* `Lint/LiteralInCondition` warns if a symbol or dynamic symbol is used as a condition. ([@alexdowad][])
* [#2369](https://github.com/bbatsov/rubocop/issues/2369): `Style/TrailingComma` doesn't add a trailing comma to a multiline method chain which is the only arg to a method call. ([@alexdowad][])
* `CircularArgumentReference` cop updated to lint for ordinal circular argument references on top of optional keyword arguments. ([@maxjacobson][])
* Added ability to download shared rubocop config files from remote urls. ([@ptrippett][])
* [#1601](https://github.com/bbatsov/rubocop/issues/1601): Add `IgnoreEmptyMethods` config parameter for `Lint/UnusedMethodArgument` and `IgnoreEmptyBlocks` config parameter for `Lint/UnusedBlockArgument` cops. ([@alexdowad][])
* [#1729](https://github.com/bbatsov/rubocop/issues/1729): `Style/MethodDefParentheses` supports new 'require_no_parentheses_except_multiline' style. ([@alexdowad][])
* [#2173](https://github.com/bbatsov/rubocop/issues/2173): `Style/AlignParameters` also checks parameter alignment for method definitions. ([@alexdowad][])
* [#1825](https://github.com/bbatsov/rubocop/issues/1825): New `NameWhitelist` configuration parameter for `Style/PredicateName` can be used to suppress errors on known-good predicate names. ([@alexdowad][])
* `Style/Documentation` recognizes 'Constant = Class.new' as a class definition. ([@alexdowad][])
* [#1608](https://github.com/bbatsov/rubocop/issues/1608): Add new 'align_braces' style for `Style/IndentHash`. ([@alexdowad][])
* `Style/Next` can autocorrect. ([@alexdowad][])
### Bug Fixes
* [#2265](https://github.com/bbatsov/rubocop/issues/2265): Handle unary `+` in `ExtraSpacing` cop. ([@jonas054][])
* [#2275](https://github.com/bbatsov/rubocop/pull/2275): Copy default `Exclude` into `Exclude` lists in `.rubocop_todo.yml`. ([@jonas054][])
* `Style/IfUnlessModifier` accepts blocks followed by a chained call. ([@lumeet][])
* [#2261](https://github.com/bbatsov/rubocop/issues/2261): Make relative `Exclude` paths in `$HOME/.rubocop_todo.yml` be relative to current directory. ([@jonas054][])
* [#2286](https://github.com/bbatsov/rubocop/issues/2286): Handle auto-correction of empty method when `AllowIfMethodIsEmpty` is `false` in `Style/SingleLineMethods`. ([@jonas054][])
* [#2246](https://github.com/bbatsov/rubocop/pull/2246): Do not register an offense for `Style/TrailingUnderscoreVariable` when the underscore variable is preceeded by a splat variable. ([@rrosenblum][])
* [#2292](https://github.com/bbatsov/rubocop/pull/2292): Results should not be stored in the cache if affected by errors (crashes). ([@jonas054][])
* [#2280](https://github.com/bbatsov/rubocop/issues/2280): Avoid reporting space between hash literal keys and values in `Style/ExtraSpacing`. ([@jonas054][])
* [#2284](https://github.com/bbatsov/rubocop/issues/2284): Fix result cache being shared between ruby versions. ([@miquella][])
* [#2285](https://github.com/bbatsov/rubocop/issues/2285): Fix `ConfigurableNaming#class_emitter_method?` error when handling singleton class methods. ([@palkan][])
* [#2295](https://github.com/bbatsov/rubocop/issues/2295): Fix Performance/Detect autocorrect to handle rogue newlines. ([@palkan][])
* [#2294](https://github.com/bbatsov/rubocop/issues/2294): Do not register an offense in `Performance/StringReplacement` for regex with options. ([@rrosenblum][])
* Fix `Style/UnneededPercentQ` condition for single-quoted literal containing interpolation-like string. ([@eagletmt][])
* [#2324](https://github.com/bbatsov/rubocop/issues/2324): Handle `--only Lint/Syntax` and `--except Lint/Syntax` correctly. ([@jonas054][])
* [#2317](https://github.com/bbatsov/rubocop/issues/2317): Handle `case` as an argument correctly in `Lint/EndAlignment`. ([@lumeet][])
* [#2287](https://github.com/bbatsov/rubocop/issues/2287): Fix auto-correct of lines with only whitespace in `Style/IndentationWidth`. ([@lumeet][])
* [#2331](https://github.com/bbatsov/rubocop/issues/2331): Do not register an offense in `Performance/Size` for `count` with an argument. ([@rrosenblum][])
* Handle a backslash at the end of a line in `Style/SpaceAroundOperators`. ([@lumeet][])
* Don't warn about lack of "leading space" in a =begin/=end comment. ([@alexdowad][])
* [#2307](https://github.com/bbatsov/rubocop/issues/2307): In `Lint/FormatParameterMismatch`, don't register an offense if either argument to % is not a literal. ([@alexdowad][])
* [#2356](https://github.com/bbatsov/rubocop/pull/2356): `Style/Encoding` will now place the encoding comment on the second line if the first line is a shebang. ([@rrosenblum][])
* `Style/InitialIndentation` cop doesn't error out when a line begins with an integer literal. ([@alexdowad][])
* [#2296](https://github.com/bbatsov/rubocop/issues/2296): In `Style/DotPosition`, don't "correct" (and break) a method call which has a line comment (or blank line) between the dot and the selector. ([@alexdowad][])
* [#2272](https://github.com/bbatsov/rubocop/issues/2272): `Lint/NonLocalExitFromIterator` does not warn about `return` in a block which is passed to `Module#define_method`. ([@alexdowad][])
* [#2262](https://github.com/bbatsov/rubocop/issues/2262): Replace `Rainbow` reference with `Colorizable#yellow`. ([@minustehbare][])
* [#2068](https://github.com/bbatsov/rubocop/issues/2068): Display warning if `Style/Copyright` is misconfigured. ([@alexdowad][])
* [#2321](https://github.com/bbatsov/rubocop/issues/2321): In `Style/EachWithObject`, don't replace reduce with each_with_object if the accumulator parameter is assigned to in the block. ([@alexdowad][])
* [#1981](https://github.com/bbatsov/rubocop/issues/1981): `Lint/UselessAssignment` doesn't erroneously identify assignments in identical if branches as useless. ([@alexdowad][])
* [#2323](https://github.com/bbatsov/rubocop/issues/2323): `Style/IfUnlessModifier` cop parenthesizes autocorrected code when necessary due to operator precedence, to avoid changing its meaning. ([@alexdowad][])
* [#2003](https://github.com/bbatsov/rubocop/issues/2003): Make `Lint/UnneededDisable` work with `--auto-correct`. ([@jonas054][])
* Default RuboCop cache dir moved to per-user folders. ([@br3nda][])
* [#2393](https://github.com/bbatsov/rubocop/pull/2393): `Style/MethodCallParentheses` doesn't fail on `obj.method ||= func()`. ([@alexdowad][])
* [#2344](https://github.com/bbatsov/rubocop/pull/2344): When autocorrecting, `Style/ParallelAssignment` reorders assignment statements, if necessary, to avoid breaking code. ([@alexdowad][])
* `Style/MultilineOperationAlignment` does not try to align the receiver and selector of a method call if both are on the LHS of an assignment. ([@alexdowad][])
### Changes
* [#2194](https://github.com/bbatsov/rubocop/issues/2194): Allow any options with `--auto-gen-config`. ([@agrimm][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
[@tejasbubane]: https://github.com/tejasbubane
[@bmorrall]: https://github.com/bmorrall
[@fphilipe]: https://github.com/fphilipe
[@gotrevor]: https://github.com/gotrevor
[@awwaiid]: https://github.com/awwaiid
[@segiddins]: https://github.com/segiddins
[@urbanautomaton]: https://github.com/urbanautomaton.com
[@unmanbearpig]: https://github.com/unmanbearpig
[@maxjacobson]: https://github.com/maxjacobson
[@sliuu]: https://github.com/sliuu
[@edmz]: https://github.com/edmz
[@syndbg]: https://github.com/syndbg
[@wli]: https://github.com/wli
[@caseywebdev]: https://github.com/caseywebdev
[@MGerrior]: https://github.com/MGerrior
[@imtayadeway]: https://github.com/imtayadeway
[@mrfoto]: https://github.com/mrfoto
[@karreiro]: https://github.com/karreiro
[@dreyks]: https://github.com/dreyks
[@hmadison]: https://github.com/hmadison
[@miquella]: https://github.com/miquella
[@jhansche]: https://github.com/jhansche
[@cornelius]: https://github.com/cornelius
[@eagletmt]: https://github.com/eagletmt
[@apiology]: https://github.com/apiology
[@alexdowad]: https://github.com/alexdowad
[@minustehbare]: https://github.com/minustehbare
[@tansaku]: https://github.com/tansaku
[@ptrippett]: https://github.com/ptrippett
[@br3nda]: https://github.com/br3nda
rubocop-0.48.1+dfsg.orig/relnotes/v0.36.0.md 0000664 0000000 0000000 00000074037 13070542236 0020237 0 ustar 00root root 0000000 0000000 An epic release - the one which contains the most new features and
bugfixes since the inception of the project! A huge thanks to the
amazing contributors who helped make it a reality!
Notably, this release adds support for Ruby 2.3 and introduces the
important concept of a target Ruby version - meaning RuboCop will no
longer try to parse the code with a parser matching the interpreter
you're using, but a parser matching the target Ruby version you
specified in `.rubocop.yml`. This way you won't introduce accidentally
syntax from a newer Ruby when you want to maintain
compatibility with certain older Rubies.
Enjoy!
### New features
* [#2598](https://github.com/bbatsov/rubocop/pull/2598): New cop `Lint/RandOne` checks for `rand(1)`, `Kernel.rand(1.0)` and similar calls. Such call are most likely a mistake because they always return `0`. ([@DNNX][])
* [#2590](https://github.com/bbatsov/rubocop/pull/2590): New cop `Performance/DoubleStartEndWith` checks for two `start_with?` (or `end_with?`) calls joined by `||` with the same receiver, like `str.start_with?('x') || str.start_with?('y')` and suggests using one call instead: `str.start_with?('x', 'y')`. ([@DNNX][])
* [#2583](https://github.com/bbatsov/rubocop/pull/2583): New cop `Performance/TimesMap` checks for `x.times.map{}` and suggests replacing them with `Array.new(x){}`. ([@DNNX][])
* [#2581](https://github.com/bbatsov/rubocop/pull/2581): New cop `Lint/NextWithoutAccumulator` finds bare `next` in `reduce`/`inject` blocks which assigns `nil` to the accumulator. ([@mvidner][])
* [#2529](https://github.com/bbatsov/rubocop/pull/2529): Add EnforcedStyle config parameter to IndentArray. ([@jawshooah][])
* [#2479](https://github.com/bbatsov/rubocop/pull/2479): Add option `AllowHeredoc` to `Metrics/LineLength`. ([@fphilipe][])
* [#2416](https://github.com/bbatsov/rubocop/pull/2416): New cop `Style/ConditionalAssignment` checks for assignment of the same variable in all branches of conditionals and replaces them with a single assignment to the return of the conditional. ([@rrosenblum][])
* [#2410](https://github.com/bbatsov/rubocop/pull/2410): New cop `Style/IndentAssignment` checks the indentation of the first line of the right-hand-side of a multi-line assignment. ([@panthomakos][])
* [#2431](https://github.com/bbatsov/rubocop/issues/2431): Add `IgnoreExecutableScripts` option to `Style/FileName`. ([@sometimesfood][])
* [#2460](https://github.com/bbatsov/rubocop/pull/2460): New cop `Style/UnneededInterpolation` checks for strings that are just an interpolated expression. ([@cgriego][])
* [#2361](https://github.com/bbatsov/rubocop/pull/2361): `Style/MultilineAssignmentLayout` cop checks for a newline after the assignment operator in a multi-line assignment. ([@panthomakos][])
* [#2462](https://github.com/bbatsov/rubocop/issues/2462): `Lint/UselessAccessModifier` can catch more types of useless access modifiers. ([@alexdowad][])
* [#1677](https://github.com/bbatsov/rubocop/issues/1677): Add new `Performance/Casecmp` cop. ([@alexdowad][])
* [#1677](https://github.com/bbatsov/rubocop/issues/1677): Add new `Performance/RangeInclude` cop. ([@alexdowad][])
* [#1677](https://github.com/bbatsov/rubocop/issues/1677): Add new `Performance/RedundantSortBy` cop. ([@alexdowad][])
* [#1677](https://github.com/bbatsov/rubocop/issues/1677): Add new `Performance/LstripRstrip` cop. ([@alexdowad][])
* [#1677](https://github.com/bbatsov/rubocop/issues/1677): Add new `Performance/StartWith` cop. ([@alexdowad][])
* [#1677](https://github.com/bbatsov/rubocop/issues/1677): Add new `Performance/EndWith` cop. ([@alexdowad][])
* [#1677](https://github.com/bbatsov/rubocop/issues/1677): Add new `Performance/RedundantMerge` cop. ([@alexdowad][])
* `Lint/Debugger` cop can now auto-correct offenses. ([@alexdowad][])
* [#1677](https://github.com/bbatsov/rubocop/issues/1677): Add new `Performance/RedundantMatch` cop. ([@alexdowad][])
* [#1677](https://github.com/bbatsov/rubocop/issues/1677): Add new `Performance/RedundantBlockCall` cop. ([@alexdowad][])
* [#1954](https://github.com/bbatsov/rubocop/issues/1954): `Lint/UnneededDisable` can now autocorrect. ([@alexdowad][])
* [#2501](https://github.com/bbatsov/rubocop/issues/2501): Add new `Lint/ImplicitStringConcatenation` cop. ([@alexdowad][])
* Add new `Style/RedundantParentheses` cop. ([@lumeet][])
* [#1346](https://github.com/bbatsov/rubocop/issues/1346): `Style/SpecialGlobalVars` can be configured to use either `use_english_names` or `use_perl_names` styles. ([@alexdowad][])
* [#2426](https://github.com/bbatsov/rubocop/issues/2426): New `Style/NestedParenthesizedCalls` cop checks for non-parenthesized method calls nested inside a parenthesized call, like `method1(method2 arg)`. ([@alexdowad][])
* [#2502](https://github.com/bbatsov/rubocop/issues/2502): The `--stdin` and `--auto-correct` CLI options can be combined, and if you do so, corrected code is printed to stdout. ([@alexdowad][])
* `Style/ConditionalAssignment` works on conditionals with a common aref assignment (like `array[index] = val`) or attribute assignment (like `self.attribute = val`). ([@alexdowad][])
* [#2476](https://github.com/bbatsov/rubocop/issues/2476): `Style/GuardClause` catches if..else nodes with one branch which terminates the execution of the current scope. ([@alexdowad][])
* New `Style/IdenticalConditionalBranches` flags `if..else` and `case..when..else` constructs with an identical line at the end of each branch. ([@alexdowad][])
* [#207](https://github.com/bbatsov/rubocop/issues/207): Add new `Lint/FloatOutOfRange` cop which catches floating-point literals which are too large or too small for Ruby to represent. ([@alexdowad][])
* `Style/GuardClause` doesn't report offenses in places where correction would make a line too long. ([@alexdowad][])
* `Lint/DuplicateMethods` can find duplicate method definitions in many more circumstances, even across multiple files; however, it ignores definitions inside `if` or something which could be a DSL method. ([@alexdowad][])
* A warning is printed if an invalid `EnforcedStyle` is configured. ([@alexdowad][])
* [#1367](https://github.com/bbatsov/rubocop/issues/1367): New `Lint/IneffectiveAccessModifier` checks for access modifiers which are erroneously applied to a singleton method, where they have no effect. ([@alexdowad][])
* [#1614](https://github.com/bbatsov/rubocop/issues/1614): `Lint/BlockAlignment` aligns block end with splat operator when applied to a splatted method call. ([@alexdowad][])
* [#2263](https://github.com/bbatsov/rubocop/issues/2263): Warn if `task.options = %w(--format ...)` is used when configuring `RuboCop::RakeTask`; this should be `task.formatters = ...` instead. ([@alexdowad][])
* [#2511](https://github.com/bbatsov/rubocop/issues/2511): `--no-offense-counts` CLI option suppresses the inclusion of offense count lines in auto-generated config. ([@alexdowad][])
* [#2504](https://github.com/bbatsov/rubocop/issues/2504): New `AllowForAlignment` config parameter for `Style/SingleSpaceBeforeFirstArg` allows the insertion of extra spaces before the first argument if it aligns it with something on the preceding or following line. ([@alexdowad][])
* [#2478](https://github.com/bbatsov/rubocop/issues/2478): `Style/ExtraSpacing` has new `ForceEqualSignAlignment` config parameter which forces = signs on consecutive lines to be aligned, and it can auto-correct. ([@alexdowad][])
* `Lint/BlockAlignment` aligns block end with unary operators like ~, -, or ! when such operators are applied to the method call taking the block. ([@alexdowad][])
* [#1460](https://github.com/bbatsov/rubocop/issues/1460): `Style/Alias` supports both `prefer_alias` and `prefer_alias_method` styles. ([@alexdowad][])
* [#1569](https://github.com/bbatsov/rubocop/issues/1569): New `ExpectMatchingDefinition` config parameter for `Style/FileName` makes it check for a class or module definition in each file which corresponds to the file name and path. ([@alexdowad][])
* [#2480](https://github.com/bbatsov/rubocop/pull/2480): Add a configuration to `Style/ConditionalAssignment` to check and correct conditionals that contain multiple assignments. ([@rrosenblum][])
* [#2480](https://github.com/bbatsov/rubocop/pull/2480): Allow `Style/ConditionalAssignment` to correct assignment in ternary operations. ([@rrosenblum][])
* [#2480](https://github.com/bbatsov/rubocop/pull/2480): Allow `Style/ConditionalAssignment` to correct comparable methods. ([@rrosenblum][])
* [#1633](https://github.com/bbatsov/rubocop/issues/1633): New cop `Style/MultilineMethodCallIndentation` takes over the responsibility for checking alignment of methods from the `Style/MultilineOperationIndentation` cop. ([@jonas054][])
* [#2472](https://github.com/bbatsov/rubocop/pull/2472): New cop `Style/MultilineArrayBraceLayout` checks that the closing brace in an array literal is symmetrical with respect to the opening brace and the array elements. ([@panthomakos][])
* [#1543](https://github.com/bbatsov/rubocop/issues/1543): `Style/WordArray` has both `percent` and `brackets` (which enforces the use of bracketed arrays for strings) styles. ([@alexdowad][])
* `Style/SpaceAroundOperators` has `AllowForAlignment` config parameter which allows extra spaces on the left if they serve to align the operator with another. ([@alexdowad][])
* `Style/SymbolArray` has both `percent` and `brackets` (which enforces the user of bracketed arrays for symbols) styles. ([@alexdowad][])
* [#2343](https://github.com/bbatsov/rubocop/issues/2343): Entire cop types (or "departments") can be disabled using in .rubocop.yml using config like `Style: Enabled: false`. ([@alexdowad][])
* [#2399](https://github.com/bbatsov/rubocop/issues/2399): New `start_of_line` style for `Lint/EndAlignment` aligns a closing `end` keyword with the start of the line where the opening keyword appears. ([@alexdowad][])
* [#1545](https://github.com/bbatsov/rubocop/issues/1545): New `Regex` config parameter for `Style/FileName` allows user to provide their own regex for validating file names. ([@alexdowad][])
* [#2253](https://github.com/bbatsov/rubocop/issues/2253): New `DefaultFormatter` config parameter can be used to set formatter from within .rubocop.yml. ([@alexdowad][])
* [#2481](https://github.com/bbatsov/rubocop/issues/2481): New `WorstOffendersFormatter` prints a list of files with offenses (and offense counts), showing the files with the most offenses first. ([@alexdowad][])
* New `IfInsideElse` cop catches `if..end` nodes which can be converted into an `elsif` instead, reducing the nesting level. ([@alexdowad][])
* [#1725](https://github.com/bbatsov/rubocop/issues/1725): --color CLI option forces color output, even when not printing to a TTY. ([@alexdowad][])
* [#2549](https://github.com/bbatsov/rubocop/issues/2549): New `ConsistentQuotesInMultiline` config param for `Style/StringLiterals` forces all literals which are concatenated using \ to use the same quote style. ([@alexdowad][])
* [#2560](https://github.com/bbatsov/rubocop/issues/2560): `Style/AccessModifierIndentation`, `Style/CaseIndentation`, `Style/FirstParameterIndentation`, `Style/IndentArray`, `Style/IndentAssignment`, `Style/IndentHash`, `Style/MultilineMethodCallIndentation`, and `Style/MultilineOperationIndentation` all have a new `IndentationWidth` parameter which can be used to override the indentation width from `Style/IndentationWidth`. ([@alexdowad][])
* Add new `Performance/HashEachMethods` cop. ([@ojab][])
* New cop `Style/FrozenStringLiteralComment` will check for and add the comment `# frozen_string_literal: true` to the top of files. This will help with upgrading to Ruby 3.0. ([@rrosenblum][])
### Bug Fixes
* [#2594](https://github.com/bbatsov/rubocop/issues/2594): `Style/EmptyLiteral` autocorrector respects `Style/StringLiterals:EnforcedStyle` config. ([@DNNX][])
* [#2411](https://github.com/bbatsov/rubocop/issues/2411): Make local inherited configuration override configuration loaded from gems. ([@jonas054][])
* [#2413](https://github.com/bbatsov/rubocop/issues/2413): Allow `%Q` for dynamic strings with double quotes inside them. ([@jonas054][])
* [#2404](https://github.com/bbatsov/rubocop/issues/2404): `Style/Next` does not remove comments when auto-correcting. ([@lumeet][])
* `Style/Next` handles auto-correction of nested offenses. ([@lumeet][])
* `Style/VariableInterpolation` now detects non-numeric regex back references. ([@cgriego][])
* `ProgressFormatter` fully respects the `--no-color` switch. ([@savef][])
* Replace `Time.zone.current` with `Time.current` on `Rails::TimeZone` cop message. ([@volmer][])
* [#2451](https://github.com/bbatsov/rubocop/issues/2451): `Style/StabbyLambdaParentheses` does not treat method calls named `lambda` as lambdas. ([@domcleal][])
* [#2463](https://github.com/bbatsov/rubocop/issues/2463): Allow comments before an access modifier. ([@codebeige][])
* [#2471](https://github.com/bbatsov/rubocop/issues/2471): `Style/MethodName` doesn't choke on methods which are defined inside methods. ([@alexdowad][])
* [#2449](https://github.com/bbatsov/rubocop/issues/2449): `Style/StabbyLambdaParentheses` only checks lambdas in the arrow form. ([@lumeet][])
* [#2456](https://github.com/bbatsov/rubocop/issues/2456): `Lint/NestedMethodDefinition` doesn't register offenses for method definitions inside an eval block (either `instance_eval`, `class_eval`, or `module_eval`). ([@alexdowad][])
* [#2464](https://github.com/bbatsov/rubocop/issues/2464): `Style/ParallelAssignment` understands aref and attribute assignments, and doesn't warn if they can't be correctly rearranged into a series of single assignments. ([@alexdowad][])
* [#2482](https://github.com/bbatsov/rubocop/issues/2482): `Style/AndOr` doesn't raise an exception when trying to autocorrect `!variable or ...`. ([@alexdowad][])
* [#2446](https://github.com/bbatsov/rubocop/issues/2446): `Style/Tab` doesn't register errors for leading tabs which occur inside a string literal (including heredoc). ([@alexdowad][])
* [#2452](https://github.com/bbatsov/rubocop/issues/2452): `Style/TrailingComma` incorrectly categorizes single-line hashes in methods calls. ([@panthomakos][])
* [#2441](https://github.com/bbatsov/rubocop/issues/2441): `Style/AlignParameters` doesn't crash if it finds nested offenses. ([@alexdowad][])
* [#2436](https://github.com/bbatsov/rubocop/issues/2436): `Style/SpaceInsideHashLiteralBraces` doesn't mangle a hash literal which is not surrounded by curly braces, but has another hash literal which does as its first key. ([@alexdowad][])
* [#2483](https://github.com/bbatsov/rubocop/issues/2483): `Style/Attr` differentiate between attr_accessor and attr_reader. ([@weh][])
* `Style/ConditionalAssignment` doesn't crash if it finds a `case` with an empty branch. ([@lumeet][])
* [#2506](https://github.com/bbatsov/rubocop/issues/2506): `Lint/FormatParameterMismatch` understands %{} and %<> interpolations. ([@alexdowad][])
* [#2145](https://github.com/bbatsov/rubocop/issues/2145): `Lint/ParenthesesAsGroupedExpression` ignores calls with multiple arguments, since they are not ambiguous. ([@alexdowad][])
* [#2484](https://github.com/bbatsov/rubocop/issues/2484): Remove two vulnerabilities in cache handling. ([@jonas054][])
* [#2517](https://github.com/bbatsov/rubocop/issues/2517): `Lint/UselessAccessModifier` doesn't think that an access modifier applied to `attr_writer` is useless. ([@alexdowad][])
* [#2518](https://github.com/bbatsov/rubocop/issues/2518): `Style/ConditionalAssignment` doesn't think that branches using `<<` and `[]=` should be combined. ([@alexdowad][])
* `CharacterLiteral` auto-corrector now properly corrects `?'`. ([@bfontaine][])
* [#2313](https://github.com/bbatsov/rubocop/issues/2313): `Rails/FindEach` doesn't break code which uses `order(...).each`, `limit(...).each`, and so on. ([@alexdowad][])
* [#1938](https://github.com/bbatsov/rubocop/issues/1938): `Rails/FindBy` doesn't autocorrect `where(...).first` to `find_by`, since the returned record is often different. ([@alexdowad][])
* [#1801](https://github.com/bbatsov/rubocop/issues/1801): `EmacsFormatter` strips newlines out of error messages, if there are any. ([@alexdowad][])
* [#2534](https://github.com/bbatsov/rubocop/issues/2534): `Style/RescueEnsureAlignment` works on `rescue` nested inside a `class` or `module` block. ([@alexdowad][])
* `Lint/BlockAlignment` does not refer to a block terminator as `end` when it is actually `}`. ([@alexdowad][])
* [#2540](https://github.com/bbatsov/rubocop/issues/2540): `Lint/FormatParameterMismatch` understands format specifiers with multiple flags. ([@alexdowad][])
* [#2538](https://github.com/bbatsov/rubocop/issues/2538): `Style/SpaceAroundOperators` doesn't eat newlines. ([@alexdowad][])
* [#2531](https://github.com/bbatsov/rubocop/issues/2531): `Style/AndOr` autocorrects in cases where parentheses must be added, even inside a nested begin node. ([@alexdowad][])
* [#2450](https://github.com/bbatsov/rubocop/issues/2450): `Style/Next` adjusts indentation when auto-correcting, to avoid introducing new offenses. ([@alexdowad][])
* [#2066](https://github.com/bbatsov/rubocop/issues/2066): `Style/TrivialAccessors` doesn't flag what appear to be trivial accessor method definitions, if they are nested inside a call to `instance_eval`. ([@alexdowad][])
* `Style/SymbolArray` doesn't flag arrays of symbols if a symbol contains a space character. ([@alexdowad][])
* `Style/SymbolArray` can auto-correct offenses. ([@alexdowad][])
* [#2546](https://github.com/bbatsov/rubocop/issues/2546): Report when two `rubocop:disable` comments (not the single line kind) for a given cop apppear in a file with no `rubocop:enable` in between. ([@jonas054][])
* [#2552](https://github.com/bbatsov/rubocop/issues/2552): `Style/Encoding` can auto-correct files with a blank first line. ([@alexdowad][])
* [#2556](https://github.com/bbatsov/rubocop/issues/2556): `Style/SpecialGlobalVariables` generates auto-config correctly. ([@alexdowad][])
* [#2565](https://github.com/bbatsov/rubocop/issues/2565): Let `Style/SpaceAroundOperators` leave spacing around `=>` to `Style/AlignHash`. ([@jonas054][])
* [#2569](https://github.com/bbatsov/rubocop/issues/2569): `Style/MethodCallParentheses` doesn't register warnings for `object.()` syntax, since it is handled by `Style/LambdaCall`. ([@alexdowad][])
* [#2570](https://github.com/bbatsov/rubocop/issues/2570): `Performance/RedundantMerge` doesn't break code with a modifier `if` when autocorrecting. ([@alexdowad][])
* `Performance/RedundantMerge` doesn't break code with a modifier `while` or `until` when autocorrecting. ([@alexdowad][])
* [#2574](https://github.com/bbatsov/rubocop/issues/2574): `variable` style for `Lint/EndAlignment` is working again. ([@alexdowad][])
* `Lint/EndAlignment` can autocorrect offenses on the RHS of an assignment to an instance variable, class variable, constant, and so on; previously, it only worked if the LHS was a local variable. ([@alexdowad][])
* [#2580](https://github.com/bbatsov/rubocop/issues/2580): `Style/StringReplacement` doesn't break code when autocorrection involves a regex with embedded escapes (like /\n/). ([@alexdowad][])
* [#2582](https://github.com/bbatsov/rubocop/issues/2582): `Style/AlignHash` doesn't move a key so far left that it goes onto the previous line (in an attempt to align). ([@alexdowad][])
* [#2588](https://github.com/bbatsov/rubocop/issues/2588): `Style/SymbolProc` doesn't break code when autocorrecting a method call with a trailing comma in the argument list. ([@alexdowad][])
* [#2448](https://github.com/bbatsov/rubocop/issues/2448): `Style/TrailingCommaInArguments` and `Style/TrailingCommaInLiteral` don't special-case single-item lists in a way which contradicts the documentation. ([@alexdowad][])
* Fix for remote config files to only load from on http and https URLs. ([@ptrippett][])
* [#2604](https://github.com/bbatsov/rubocop/issues/2604): `Style/FileName` doesn't fail on empty files when `ExpectMatchingDefinition` is true. ([@alexdowad][])
* `Style/RedundantFreeze` registers offences for frozen dynamic symbols. ([@segiddins][])
* [#2609](https://github.com/bbatsov/rubocop/issues/2609): All cops which rely on the `AutocorrectUnlessChangingAST` module can now autocorrect files which contain `__FILE__`. ([@alexdowad][])
* [#2608](https://github.com/bbatsov/rubocop/issues/2608): `Style/ConditionalAssignment` can autocorrect `=~` within a ternary expression. ([@alexdowad][])
### Changes
* [#2427](https://github.com/bbatsov/rubocop/pull/2427): Allow non-snake-case file names (e.g. `some-random-script`) for Ruby scripts that have a shebang. ([@sometimesfood][])
* [#2430](https://github.com/bbatsov/rubocop/pull/2430): `Lint/UnneededDisable` now adds "unknown cop" to messages if cop names in `rubocop:disable` comments are unrecognized, or "did you mean ..." if they are misspelled names of existing cops. ([@jonas054][])
* [#947](https://github.com/bbatsov/rubocop/issues/947): `Style/Documentation` considers classes and modules which only define constants to be "namespaces", and doesn't flag them for lack of a documentation comment. ([@alexdowad][])
* [#2467](https://github.com/bbatsov/rubocop/issues/2467): Explicitly inheriting configuration from the rubocop gem in .rubocop.yml is not allowed. ([@alexdowad][])
* [#2322](https://github.com/bbatsov/rubocop/issues/2322): Output of --auto-gen-config shows content of default config parameters which are Arrays; this is especially useful for SupportedStyles. ([@alexdowad][])
* [#1566](https://github.com/bbatsov/rubocop/issues/1566): When autocorrecting on Windows, line endings are not converted to "\r\n" in untouched portions of the source files; corrected portions may use "\n" rather than "\r\n". ([@alexdowad][])
* New `rake repl` task can be used for experimentation when working on RuboCop. ([@alexdowad][])
* `Lint/SpaceBeforeFirstArg` cop has been removed, since it just duplicates `Style/SingleSpaceBeforeFirstArg`. ([@alexdowad][])
* `Style/SingleSpaceBeforeFirstArg` cop has been renamed to `Style/SpaceBeforeFirstArg`, which more accurately reflects what it now does. ([@alexdowad][])
* `Style/UnneededPercentQ` reports `%q()` strings with what only appears to be an escape, but is not really (there are no escapes in `%q()` strings). ([@alexdowad][])
* `Performance/StringReplacement`, `Performance\StartWith`, and `Performance\EndWith` more accurately identify code which can be improved. ([@alexdowad][])
* The `MultiSpaceAllowedForOperators` config parameter for `Style/SpaceAroundOperators` has been removed, as it is made redundant by `AllowForAlignment`. If someone attempts to use it, config validation will fail with a helpful message. ([@alexdowad][])
* The `RunRailsCops` config parameter in .rubocop.yml is now obsolete. If someone attempts to use it, config validation will fail with a helpful message. ([@alexdowad][])
* If .rubocop.yml contains configuration for a custom cop, no warning regarding "unknown cop" will be printed. The custom cop must inherit from RuboCop::Cop::Cop, and must be loaded into memory for this to work. ([@alexdowad][])
* [#2102](https://github.com/bbatsov/rubocop/issues/2102): If .rubocop.yml exists in the working directory when running --auto-gen-config, any `Exclude` config parameters in .rubocop.yml will be merged into the generated .rubocop_todo.yml. ([@alexdowad][])
* [#1895](https://github.com/bbatsov/rubocop/issues/1895): Remove `Rails/DefaultScope` cop. ([@alexdowad][])
* [#2550](https://github.com/bbatsov/rubocop/issues/2550): New `TargetRubyVersion` configuration parameter can be used to specify which version of the Ruby interpreter the inspected code is intended to run on. ([@alexdowad][])
* [#2557](https://github.com/bbatsov/rubocop/issues/2557): `Style/GuardClause` does not warn about `if` nodes whose condition spans multiple lines. ([@alexdowad][])
* `Style/EmptyLinesAroundClassBody`, `Style/EmptyLinesAroundModuleBody`, and `Style/EmptyLinesAroundBlockBody` accept an empty body with no blank line, even if configured to `empty_lines` style. This is because the empty lines only serve to provide a break between the header, body, and footer, and are redundant if there is no body. ([@alexdowad][])
* [#2554](https://github.com/bbatsov/rubocop/issues/2554): `Style/FirstMethodArgumentLineBreak` handles implicit hash arguments without braces; `Style/FirstHashElementLineBreak` still handles those with braces. ([@alexdowad][])
* `Style/TrailingComma` has been split into `Style/TrailingCommaInArguments` and `Style/TrailingCommaInLiteral`. ([@alexdowad][])
* RuboCop returns process exit code 2 if it fails due to bad configuration, bad CLI options, or an internal error. If it runs successfully but finds one or more offenses, it still exits with code 1, as was previously the case. This is helpful when invoking RuboCop programmatically, perhaps from a script. ([@alexdowad][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
[@tejasbubane]: https://github.com/tejasbubane
[@bmorrall]: https://github.com/bmorrall
[@fphilipe]: https://github.com/fphilipe
[@gotrevor]: https://github.com/gotrevor
[@awwaiid]: https://github.com/awwaiid
[@segiddins]: https://github.com/segiddins
[@urbanautomaton]: https://github.com/urbanautomaton.com
[@unmanbearpig]: https://github.com/unmanbearpig
[@maxjacobson]: https://github.com/maxjacobson
[@sliuu]: https://github.com/sliuu
[@edmz]: https://github.com/edmz
[@syndbg]: https://github.com/syndbg
[@wli]: https://github.com/wli
[@caseywebdev]: https://github.com/caseywebdev
[@MGerrior]: https://github.com/MGerrior
[@imtayadeway]: https://github.com/imtayadeway
[@mrfoto]: https://github.com/mrfoto
[@karreiro]: https://github.com/karreiro
[@dreyks]: https://github.com/dreyks
[@hmadison]: https://github.com/hmadison
[@miquella]: https://github.com/miquella
[@jhansche]: https://github.com/jhansche
[@cornelius]: https://github.com/cornelius
[@eagletmt]: https://github.com/eagletmt
[@apiology]: https://github.com/apiology
[@alexdowad]: https://github.com/alexdowad
[@minustehbare]: https://github.com/minustehbare
[@tansaku]: https://github.com/tansaku
[@ptrippett]: https://github.com/ptrippett
[@br3nda]: https://github.com/br3nda
[@jujugrrr]: https://github.com/jujugrrr
[@sometimesfood]: https://github.com/sometimesfood
[@cgriego]: https://github.com/cgriego
[@savef]: https://github.com/savef
[@volmer]: https://github.com/volmer
[@domcleal]: https://github.com/domcleal
[@codebeige]: https://github.com/codebeige
[@weh]: https://github.com/weh
[@bfontaine]: https://github.com/bfontaine
[@jawshooah]: https://github.com/jawshooah
[@DNNX]: https://github.com/DNNX
[@mvidner]: https://github.com/mvidner
rubocop-0.48.1+dfsg.orig/relnotes/v0.37.0.md 0000664 0000000 0000000 00000030312 13070542236 0020224 0 ustar 00root root 0000000 0000000 ### New features
* [#2620](https://github.com/bbatsov/rubocop/pull/2620): New cop `Style/ZeroLengthPredicate` checks for `object.size == 0` and variants, and suggests replacing them with an appropriate `empty?` predicate. ([@drenmi][])
* [#2657](https://github.com/bbatsov/rubocop/pull/2657): Floating headers in HTML output. ([@mattparlane][])
* Add new `Style/SpaceAroundKeyword` cop. ([@lumeet][])
* [#2745](https://github.com/bbatsov/rubocop/pull/2745): New cop `Style/MultilineHashBraceLayout` checks that the closing brace in a hash literal is symmetrical with respect to the opening brace and the hash elements. ([@panthomakos][])
* [#2761](https://github.com/bbatsov/rubocop/pull/2761): New cop `Style/MultilineMethodDefinitionBraceLayout` checks that the closing brace in a method definition is symmetrical with respect to the opening brace and the method parameters. ([@panthomakos][])
* [#2699](https://github.com/bbatsov/rubocop/pull/2699): `Performance/Casecmp` can register offenses when `str.downcase` or `str.upcase` are passed to an equality method. ([@rrosenblum][])
* [#2766](https://github.com/bbatsov/rubocop/pull/2766): New cop `Style/MultilineMethodCallBraceLayout` checks that the closing brace in a method call is symmetrical with respect to the opening brace and the method arguments. ([@panthomakos][])
### Bug fixes
* [#2723](https://github.com/bbatsov/rubocop/issues/2723): Fix NoMethodError in Style/GuardClause. ([@drenmi][])
* [#2674](https://github.com/bbatsov/rubocop/issues/2674): Also check for Hash#update alias in `Performance/RedundantMerge`. ([@drenmi][])
* [#2630](https://github.com/bbatsov/rubocop/issues/2630): Take frozen string literals into account in `Style/MutableConstant`. ([@segiddins][])
* [#2642](https://github.com/bbatsov/rubocop/issues/2642): Support assignment via `||=` in `Style/MutableConstant`. ([@segiddins][])
* [#2646](https://github.com/bbatsov/rubocop/issues/2646): Fix auto-correcting assignment to a constant in `Style/ConditionalAssignment`. ([@segiddins][])
* [#2614](https://github.com/bbatsov/rubocop/issues/2614): Check for zero return value from `casecmp` in `Performance/casecmp`. ([@segiddins][])
* [#2647](https://github.com/bbatsov/rubocop/issues/2647): Allow `xstr` interpolations in `Lint/LiteralInInterpolation`. ([@segiddins][])
* Report a violation when `freeze` is called on a frozen string literal in `Style/RedundantFreeze`. ([@segiddins][])
* [#2641](https://github.com/bbatsov/rubocop/issues/2641): Fix crashing on empty methods with block args in `Perfomance/RedundantBlockCall`. ([@segiddins][])
* `Lint/DuplicateMethods` doesn't crash when `class_eval` is used with an implicit receiver. ([@lumeet][])
* [#2654](https://github.com/bbatsov/rubocop/issues/2654): Fix handling of unary operations in `Style/RedundantParentheses`. ([@lumeet][])
* [#2661](https://github.com/bbatsov/rubocop/issues/2661): `Style/Next` doesn't crash when auto-correcting modifier `if/unless`. ([@lumeet][])
* [#2665](https://github.com/bbatsov/rubocop/pull/2665): Make specs pass when running on Windows. ([@jonas054][])
* [#2691](https://github.com/bbatsov/rubocop/pull/2691): Do not register an offense in `Performance/TimesMap` for calling `map` or `collect` on a variable named `times`. ([@rrosenblum][])
* [#2689](https://github.com/bbatsov/rubocop/pull/2689): Change `Performance/RedundantBlockCall` to respect parentheses usage. ([@rrosenblum][])
* [#2694](https://github.com/bbatsov/rubocop/issues/2694): Fix caching when using a different JSON gem such as Oj. ([@stormbreakerbg][])
* [#2707](https://github.com/bbatsov/rubocop/pull/2707): Change `Lint/NestedMethodDefinition` to respect `Class.new` and `Module.new`. ([@owst][])
* [#2701](https://github.com/bbatsov/rubocop/pull/2701): Do not consider assignments to the same variable as useless if later assignments are within a loop. ([@owst][])
* [#2696](https://github.com/bbatsov/rubocop/issues/2696): `Style/NestedModifier` adds parentheses around a condition when needed. ([@lumeet][])
* [#2666](https://github.com/bbatsov/rubocop/issues/2666): Fix bug when auto-correcting symbol literals in `Lint/LiteralInInterpolation`. ([@lumeet][])
* [#2664](https://github.com/bbatsov/rubocop/issues/2664): `Performance/Casecmp` can auto-correct case comparison to variables and method calls without error. ([@rrosenblum][])
* [#2729](https://github.com/bbatsov/rubocop/issues/2729): Fix handling of hash literal as the first argument in `Style/RedundantParentheses`. ([@lumeet][])
* [#2703](https://github.com/bbatsov/rubocop/issues/2703): Handle byte order mark in `Style/IndentationWidth`, `Style/ElseAlignment`, `Lint/EndAlignment`, and `Lint/DefEndAlignment`. ([@jonas054][])
* [#2710](https://github.com/bbatsov/rubocop/pull/2710): Fix handling of fullwidth characters in some cops. ([@seikichi][])
* [#2690](https://github.com/bbatsov/rubocop/issues/2690): Fix alignment of operands that are part of an assignment in `Style/MultilineOperationIndentation`. ([@jonas054][])
* [#2228](https://github.com/bbatsov/rubocop/issues/2228): Use the config of a related cop whether it's enabled or not. ([@madwort][])
* [#2721](https://github.com/bbatsov/rubocop/issues/2721): Do not register an offense for constants wrapped in parentheses passed to `rescue` in `Style/RedundantParentheses`. ([@rrosenblum][])
* [#2742](https://github.com/bbatsov/rubocop/issues/2742): Fix `Style/TrailingCommaInArguments` & `Style/TrailingCommaInLiteral` for inline single element arrays. ([@annih][])
* [#2768](https://github.com/bbatsov/rubocop/issues/2768): Allow parentheses after keyword `not` in `Style/MethodCallParentheses`. ([@lumeet][])
* [#2758](https://github.com/bbatsov/rubocop/issues/2758): Allow leading underscores in camel case variable names.([@mmcguinn][])
### Changes
* Remove `Style/SpaceAfterControlKeyword` and `Style/SpaceBeforeModifierKeyword` as the more generic `Style/SpaceAroundKeyword` handles the same cases. ([@lumeet][])
* Handle comparisons with `!=` in `Performance/casecmp`. ([@segiddins][])
* [#2684](https://github.com/bbatsov/rubocop/pull/2684): Do not base `Style/FrozenStringLiteralComment` on the version of Ruby that is running. ([@rrosenblum][])
* [#2732](https://github.com/bbatsov/rubocop/issues/2732): Change the default style of `Style/SignalException` to `only_raise`. ([@bbatsov][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
[@tejasbubane]: https://github.com/tejasbubane
[@bmorrall]: https://github.com/bmorrall
[@fphilipe]: https://github.com/fphilipe
[@gotrevor]: https://github.com/gotrevor
[@awwaiid]: https://github.com/awwaiid
[@segiddins]: https://github.com/segiddins
[@urbanautomaton]: https://github.com/urbanautomaton.com
[@unmanbearpig]: https://github.com/unmanbearpig
[@maxjacobson]: https://github.com/maxjacobson
[@sliuu]: https://github.com/sliuu
[@edmz]: https://github.com/edmz
[@syndbg]: https://github.com/syndbg
[@wli]: https://github.com/wli
[@caseywebdev]: https://github.com/caseywebdev
[@MGerrior]: https://github.com/MGerrior
[@imtayadeway]: https://github.com/imtayadeway
[@mrfoto]: https://github.com/mrfoto
[@karreiro]: https://github.com/karreiro
[@dreyks]: https://github.com/dreyks
[@hmadison]: https://github.com/hmadison
[@miquella]: https://github.com/miquella
[@jhansche]: https://github.com/jhansche
[@cornelius]: https://github.com/cornelius
[@eagletmt]: https://github.com/eagletmt
[@apiology]: https://github.com/apiology
[@alexdowad]: https://github.com/alexdowad
[@minustehbare]: https://github.com/minustehbare
[@tansaku]: https://github.com/tansaku
[@ptrippett]: https://github.com/ptrippett
[@br3nda]: https://github.com/br3nda
[@jujugrrr]: https://github.com/jujugrrr
[@sometimesfood]: https://github.com/sometimesfood
[@cgriego]: https://github.com/cgriego
[@savef]: https://github.com/savef
[@volmer]: https://github.com/volmer
[@domcleal]: https://github.com/domcleal
[@codebeige]: https://github.com/codebeige
[@weh]: https://github.com/weh
[@bfontaine]: https://github.com/bfontaine
[@jawshooah]: https://github.com/jawshooah
[@DNNX]: https://github.com/DNNX
[@mvidner]: https://github.com/mvidner
[@mattparlane]: https://github.com/mattparlane
[@drenmi]: https://github.com/drenmi
[@stormbreakerbg]: https://github.com/stormbreakerbg
[@owst]: https://github.com/owst
[@seikichi]: https://github.com/seikichi
[@madwort]: https://github.com/madwort
[@annih]: https://github.com/annih
[@mmcguinn]: https://github.com/mmcguinn
rubocop-0.48.1+dfsg.orig/relnotes/v0.37.1.md 0000664 0000000 0000000 00000021567 13070542236 0020241 0 ustar 00root root 0000000 0000000 ### New features
* [#2798](https://github.com/bbatsov/rubocop/pull/2798): `Rails/FindEach` cop works with `where.not`. ([@pocke][])
* `Style/MultilineBlockLayout` can correct offenses which involve argument destructuring. ([@alexdowad][])
* `Style/SpaceAroundKeyword` checks `super` nodes with no args. ([@alexdowad][])
* `Style/SpaceAroundKeyword` checks `defined?` nodes. ([@alexdowad][])
* [#2719](https://github.com/bbatsov/rubocop/issues/2719): `Style/ConditionalAssignment` handles correcting the alignment of `end`. ([@rrosenblum][])
### Bug fixes
* Fix auto-correction of `not` with parentheses in `Style/Not`. ([@lumeet][])
* [#2784](https://github.com/bbatsov/rubocop/issues/2784): RuboCop can inspect `super { ... }` and `super(arg) { ... }`. ([@alexdowad][])
* [#2781](https://github.com/bbatsov/rubocop/issues/2781): `Performance/RedundantMerge` doesn't flag calls to `#update`, since many classes have methods by this name (not only `Hash`). ([@alexdowad][])
* [#2780](https://github.com/bbatsov/rubocop/issues/2780): `Lint/DuplicateMethods` does not flag method definitions inside dynamic `Class.new` blocks. ([@alexdowad][])
* [#2775](https://github.com/bbatsov/rubocop/issues/2775): `Style/SpaceAroundKeyword` doesn't flag `yield.method`. ([@alexdowad][])
* [#2774](https://github.com/bbatsov/rubocop/issues/2774): `Style/SpaceAroundOperators` doesn't flag calls to `#[]`. ([@alexdowad][])
* [#2772](https://github.com/bbatsov/rubocop/issues/2772): RuboCop doesn't crash when `AllCops` section in configuration file is empty (rather, it displays a warning as intended). ([@alexdowad][])
* [#2737](https://github.com/bbatsov/rubocop/issues/2737): `Style/GuardClause` handles `elsif` clauses correctly. ([@alexdowad][])
* [#2735](https://github.com/bbatsov/rubocop/issues/2735): `Style/MultilineBlockLayout` doesn't cause an infinite loop by moving `end` onto the same line as the block args. ([@alexdowad][])
* [#2715](https://github.com/bbatsov/rubocop/issues/2715): `Performance/RedundantMatch` doesn't flag calls to `#match` which take a block. ([@alexdowad][])
* [#2704](https://github.com/bbatsov/rubocop/issues/2704): `Lint/NestedMethodDefinition` doesn't flag singleton defs which define a method on the value of a local variable. ([@alexdowad][])
* [#2660](https://github.com/bbatsov/rubocop/issues/2660): `Style/TrailingUnderscoreVariable` shows recommended code in its offense message. ([@alexdowad][])
* [#2671](https://github.com/bbatsov/rubocop/issues/2671): `Style/WordArray` doesn't attempt to inspect strings with invalid encoding, to avoid failing with an encoding error. ([@alexdowad][])
### Changes
* [#2739](https://github.com/bbatsov/rubocop/issues/2739): Change the configuration option `when_needed` in `Style/FrozenStringLiteralComment` to add a `frozen_string_literal` comment to all files when the `TargetRubyVersion` is set to 2.3+. ([@rrosenblum][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
[@tejasbubane]: https://github.com/tejasbubane
[@bmorrall]: https://github.com/bmorrall
[@fphilipe]: https://github.com/fphilipe
[@gotrevor]: https://github.com/gotrevor
[@awwaiid]: https://github.com/awwaiid
[@segiddins]: https://github.com/segiddins
[@urbanautomaton]: https://github.com/urbanautomaton.com
[@unmanbearpig]: https://github.com/unmanbearpig
[@maxjacobson]: https://github.com/maxjacobson
[@sliuu]: https://github.com/sliuu
[@edmz]: https://github.com/edmz
[@syndbg]: https://github.com/syndbg
[@wli]: https://github.com/wli
[@caseywebdev]: https://github.com/caseywebdev
[@MGerrior]: https://github.com/MGerrior
[@imtayadeway]: https://github.com/imtayadeway
[@mrfoto]: https://github.com/mrfoto
[@karreiro]: https://github.com/karreiro
[@dreyks]: https://github.com/dreyks
[@hmadison]: https://github.com/hmadison
[@miquella]: https://github.com/miquella
[@jhansche]: https://github.com/jhansche
[@cornelius]: https://github.com/cornelius
[@eagletmt]: https://github.com/eagletmt
[@apiology]: https://github.com/apiology
[@alexdowad]: https://github.com/alexdowad
[@minustehbare]: https://github.com/minustehbare
[@tansaku]: https://github.com/tansaku
[@ptrippett]: https://github.com/ptrippett
[@br3nda]: https://github.com/br3nda
[@jujugrrr]: https://github.com/jujugrrr
[@sometimesfood]: https://github.com/sometimesfood
[@cgriego]: https://github.com/cgriego
[@savef]: https://github.com/savef
[@volmer]: https://github.com/volmer
[@domcleal]: https://github.com/domcleal
[@codebeige]: https://github.com/codebeige
[@weh]: https://github.com/weh
[@bfontaine]: https://github.com/bfontaine
[@jawshooah]: https://github.com/jawshooah
[@DNNX]: https://github.com/DNNX
[@mvidner]: https://github.com/mvidner
[@mattparlane]: https://github.com/mattparlane
[@drenmi]: https://github.com/drenmi
[@stormbreakerbg]: https://github.com/stormbreakerbg
[@owst]: https://github.com/owst
[@seikichi]: https://github.com/seikichi
[@madwort]: https://github.com/madwort
[@annih]: https://github.com/annih
[@mmcguinn]: https://github.com/mmcguinn
[@pocke]: https://github.com/pocke
rubocop-0.48.1+dfsg.orig/relnotes/v0.37.2.md 0000664 0000000 0000000 00000017271 13070542236 0020237 0 ustar 00root root 0000000 0000000 ### Bug fixes
* Fix auto-correction of array and hash literals in `Lint/LiteralInInterpolation`. ([@lumeet][])
* [#2815](https://github.com/bbatsov/rubocop/pull/2815): Fix missing assets for html formatter. ([@prsimp][])
* `Style/RedundantParentheses` catches offenses involving the 2nd argument to a method call without parentheses, if the 2nd argument is a hash. ([@alexdowad][])
* `Style/RedundantParentheses` catches offenses inside an array literal. ([@alexdowad][])
* `Style/RedundantParentheses` doesn't flag `method (:arg) {}`, since removing the parentheses would change the meaning of the expression. ([@alexdowad][])
* `Performance/Detect` doesn't flag code where `first` or `last` takes an argument, as it cannot be transformed to equivalent code using `detect`. ([@alexdowad][])
* `Style/SpaceAroundOperators` ignores aref assignments. ([@alexdowad][])
* `Style/RescueModifier` indents code correctly when auto-correcting. ([@alexdowad][])
* `Style/RedundantMerge` indents code correctly when auto-correcting, even if the corrected hash had multiple keys, and even if the corrected code was indented to start with. ([@alexdowad][])
* [#2831](https://github.com/bbatsov/rubocop/issues/2831): `Performance/RedundantMerge` doesn't break code by autocorrecting a `#merge!` call which occurs at tail position in a block. ([@alexdowad][])
### Changes
* Handle auto-correction of nested interpolations in `Lint/LiteralInInterpolation`. ([@lumeet][])
* RuboCop results cache uses different directory names when there are many (or long) CLI options, to avoid a very long path which could cause failures on some filesystems. ([@alexdowad][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
[@tejasbubane]: https://github.com/tejasbubane
[@bmorrall]: https://github.com/bmorrall
[@fphilipe]: https://github.com/fphilipe
[@gotrevor]: https://github.com/gotrevor
[@awwaiid]: https://github.com/awwaiid
[@segiddins]: https://github.com/segiddins
[@urbanautomaton]: https://github.com/urbanautomaton.com
[@unmanbearpig]: https://github.com/unmanbearpig
[@maxjacobson]: https://github.com/maxjacobson
[@sliuu]: https://github.com/sliuu
[@edmz]: https://github.com/edmz
[@syndbg]: https://github.com/syndbg
[@wli]: https://github.com/wli
[@caseywebdev]: https://github.com/caseywebdev
[@MGerrior]: https://github.com/MGerrior
[@imtayadeway]: https://github.com/imtayadeway
[@mrfoto]: https://github.com/mrfoto
[@karreiro]: https://github.com/karreiro
[@dreyks]: https://github.com/dreyks
[@hmadison]: https://github.com/hmadison
[@miquella]: https://github.com/miquella
[@jhansche]: https://github.com/jhansche
[@cornelius]: https://github.com/cornelius
[@eagletmt]: https://github.com/eagletmt
[@apiology]: https://github.com/apiology
[@alexdowad]: https://github.com/alexdowad
[@minustehbare]: https://github.com/minustehbare
[@tansaku]: https://github.com/tansaku
[@ptrippett]: https://github.com/ptrippett
[@br3nda]: https://github.com/br3nda
[@jujugrrr]: https://github.com/jujugrrr
[@sometimesfood]: https://github.com/sometimesfood
[@cgriego]: https://github.com/cgriego
[@savef]: https://github.com/savef
[@volmer]: https://github.com/volmer
[@domcleal]: https://github.com/domcleal
[@codebeige]: https://github.com/codebeige
[@weh]: https://github.com/weh
[@bfontaine]: https://github.com/bfontaine
[@jawshooah]: https://github.com/jawshooah
[@DNNX]: https://github.com/DNNX
[@mvidner]: https://github.com/mvidner
[@mattparlane]: https://github.com/mattparlane
[@drenmi]: https://github.com/drenmi
[@stormbreakerbg]: https://github.com/stormbreakerbg
[@owst]: https://github.com/owst
[@seikichi]: https://github.com/seikichi
[@madwort]: https://github.com/madwort
[@annih]: https://github.com/annih
[@mmcguinn]: https://github.com/mmcguinn
[@pocke]: https://github.com/pocke
[@prsimp]: https://github.com/prsimp
rubocop-0.48.1+dfsg.orig/relnotes/v0.38.0.md 0000664 0000000 0000000 00000031341 13070542236 0020230 0 ustar 00root root 0000000 0000000 ### New features
* `Style/UnlessElse` cop can auto-correct. ([@lumeet][])
* [#2629](https://github.com/bbatsov/rubocop/pull/2629): Add a new public API method, `highlighted_area` to offense. This method returns the range of the highlighted portion of an offense. ([@rrosenblum][])
* `Style/OneLineConditional` cop can auto-correct. ([@lumeet][])
* [#2905](https://github.com/bbatsov/rubocop/issues/2905): `Style/ZeroLengthConditional` flags code like `array.length < 1`, `1 > array.length`, and so on. ([@alexdowad][])
* [#2892](https://github.com/bbatsov/rubocop/issues/2892): `Lint/BlockAlignment` cop can be configured to be stricter. ([@ptarjan][])
* `Style/Not` is able to autocorrect in cases where parentheses must be added to preserve the meaning of an expression. ([@alexdowad][])
* `Style/Not` auto-corrects comparison expressions by removing `not` and using the opposite comparison. ([@alexdowad][])
### Bug fixes
* Add `require 'time'` to `remote_config.rb` to avoid "undefined method \`rfc2822'". ([@necojackarc][])
* Replace `Rake::TaskManager#last_comment` with `Rake::TaskManager#last_description` for Rake 11 compatibility. ([@tbrisker][])
* Fix false positive in `Style/TrailingCommaInArguments` & `Style/TrailingCommaInLiteral` cops with consistent_comma style. ([@meganemura][])
* [#2861](https://github.com/bbatsov/rubocop/pull/2861): Fix false positive in `Style/SpaceAroundKeyword` for `rescue(...`. ([@rrosenblum][])
* [#2832](https://github.com/bbatsov/rubocop/issues/2832): `Style/MultilineOperationIndentation` treats operations inside blocks inside other operations correctly. ([@jonas054][])
* [#2865](https://github.com/bbatsov/rubocop/issues/2865): Change `require:` in config to be relative to the `.rubocop.yml` file itself. ([@ptarjan][])
* [#2845](https://github.com/bbatsov/rubocop/issues/2845): Handle heredocs in `Style/MultilineLiteralBraceLayout` auto-correct. ([@jonas054][])
* [#2848](https://github.com/bbatsov/rubocop/issues/2848): Handle comments inside arrays in `Style/MultilineArrayBraceLayout` auto-correct. ([@jonas054][])
* `Style/TrivialAccessors` allows predicate methods by default. ([@alexdowad][])
* [#2869](https://github.com/bbatsov/rubocop/issues/2869): Offenses which occur in the body of a `when` clause with multiple arguments will not be missed. ([@alexdowad][])
* `Lint/UselessAccessModifier` recognizes method defs inside a `begin` block. ([@alexdowad][])
* [#2870](https://github.com/bbatsov/rubocop/issues/2870): `Lint/UselessAccessModifier` recognizes method definitions which are passed as an argument to a method call. ([@alexdowad][])
* [#2859](https://github.com/bbatsov/rubocop/issues/2859): `Style/RedundantParentheses` doesn't consider the parentheses in `(!receiver.method arg)` to be redundant, since they might change the meaning of an expression, depending on precedence. ([@alexdowad][])
* [#2852](https://github.com/bbatsov/rubocop/issues/2852): `Performance/Casecmp` doesn't flag uses of `downcase`/`upcase` which are not redundant. ([@alexdowad][])
* [#2850](https://github.com/bbatsov/rubocop/issues/2850): `Style/FileName` doesn't choke on empty files with spaces in their names. ([@alexdowad][])
* [#2834](https://github.com/bbatsov/rubocop/issues/2834): When configured as `ConsistentQuotesInMultiline: true`, `Style/StringLiterals` doesn't error out when inspecting a heredoc with differing indentation across multiple lines. ([@alexdowad][])
* [#2876](https://github.com/bbatsov/rubocop/issues/2876): `Style/ConditionalAssignment` behaves correctly when assignment statement uses a character which has a special meaning in a regex. ([@alexdowad][])
* [#2877](https://github.com/bbatsov/rubocop/issues/2877): `Style/SpaceAroundKeyword` doesn't flag `!super.method`, `!yield.method`, and so on. ([@alexdowad][])
* [#2631](https://github.com/bbatsov/rubocop/issues/2631): `Style/Encoding` can remove unneeded encoding comment when autocorrecting with `when_needed` style. ([@alexdowad][])
* [#2860](https://github.com/bbatsov/rubocop/issues/2860): Fix false positive in `Rails/Date` when `to_time` is chained with safe method. ([@palkan][])
* [#2898](https://github.com/bbatsov/rubocop/issues/2898): `Lint/NestedMethodDefinition` allows methods defined inside `Class.new(S)` blocks. ([@segiddins][])
* [#2894](https://github.com/bbatsov/rubocop/issues/2894): Fix auto-correct an unless with a comparison operator. ([@jweir][])
* [#2911](https://github.com/bbatsov/rubocop/issues/2911): `Style/ClassAndModuleChildren` doesn't flag nested class definitions, where the outer class has an explicit superclass (because such definitions can't be converted to `compact` style). ([@alexdowad][])
* [#2871](https://github.com/bbatsov/rubocop/issues/2871): Don't crash when offense messages are read back from cache with `ASCII-8BIT` encoding and output as HTML or JSON. ([@jonas054][])
* [#2901](https://github.com/bbatsov/rubocop/issues/2901): Don't crash when `ENV['HOME']` is undefined. ([@mikegee][])
* [#2627](https://github.com/bbatsov/rubocop/issues/2627): `Style/BlockDelimiters` does not flag blocks delimited by `{}` when a block call is the final value in a hash with implicit braces (one which is the last argument to an outer method call). ([@alexdowad][])
### Changes
* Update Rake to version 11. ([@tbrisker][])
* [#2629](https://github.com/bbatsov/rubocop/pull/2629): Change the offense range for metrics cops to default to `expression` instead of `keyword` (the offense now spans the entire method, class, or module). ([@rrosenblum][])
* [#2891](https://github.com/bbatsov/rubocop/pull/2891): Change the caching of remote configs to live alongside the parent file. ([@Fryguy][])
* [#2662](https://github.com/bbatsov/rubocop/issues/2662): When setting options for Rake task, nested arrays can be used in the `options`, `formatters`, and `requires` arrays. ([@alexdowad][])
* [#2925](https://github.com/bbatsov/rubocop/pull/2925): Bump unicode-display_width dependency to >= 1.0.1. ([@jspanjers][])
* [#2875](https://github.com/bbatsov/rubocop/issues/2875): `Style/SignalException` does not flag calls to `fail` if a custom method named `fail` is defined in the same file. ([@alexdowad][])
* [#2923](https://github.com/bbatsov/rubocop/issues/2923): `Style/FileName` considers file names which contain a ? or ! character to still be "snake case". ([@alexdowad][])
* [#2879](https://github.com/bbatsov/rubocop/issues/2879): When autocorrecting, `Lint/UnusedMethodArgument` removes unused block arguments rather than simply prefixing them with an underscore. ([@alexdowad][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
[@tejasbubane]: https://github.com/tejasbubane
[@bmorrall]: https://github.com/bmorrall
[@fphilipe]: https://github.com/fphilipe
[@gotrevor]: https://github.com/gotrevor
[@awwaiid]: https://github.com/awwaiid
[@segiddins]: https://github.com/segiddins
[@urbanautomaton]: https://github.com/urbanautomaton.com
[@unmanbearpig]: https://github.com/unmanbearpig
[@maxjacobson]: https://github.com/maxjacobson
[@sliuu]: https://github.com/sliuu
[@edmz]: https://github.com/edmz
[@syndbg]: https://github.com/syndbg
[@wli]: https://github.com/wli
[@caseywebdev]: https://github.com/caseywebdev
[@MGerrior]: https://github.com/MGerrior
[@imtayadeway]: https://github.com/imtayadeway
[@mrfoto]: https://github.com/mrfoto
[@karreiro]: https://github.com/karreiro
[@dreyks]: https://github.com/dreyks
[@hmadison]: https://github.com/hmadison
[@miquella]: https://github.com/miquella
[@jhansche]: https://github.com/jhansche
[@cornelius]: https://github.com/cornelius
[@eagletmt]: https://github.com/eagletmt
[@apiology]: https://github.com/apiology
[@alexdowad]: https://github.com/alexdowad
[@minustehbare]: https://github.com/minustehbare
[@tansaku]: https://github.com/tansaku
[@ptrippett]: https://github.com/ptrippett
[@br3nda]: https://github.com/br3nda
[@jujugrrr]: https://github.com/jujugrrr
[@sometimesfood]: https://github.com/sometimesfood
[@cgriego]: https://github.com/cgriego
[@savef]: https://github.com/savef
[@volmer]: https://github.com/volmer
[@domcleal]: https://github.com/domcleal
[@codebeige]: https://github.com/codebeige
[@weh]: https://github.com/weh
[@bfontaine]: https://github.com/bfontaine
[@jawshooah]: https://github.com/jawshooah
[@DNNX]: https://github.com/DNNX
[@mvidner]: https://github.com/mvidner
[@mattparlane]: https://github.com/mattparlane
[@drenmi]: https://github.com/drenmi
[@stormbreakerbg]: https://github.com/stormbreakerbg
[@owst]: https://github.com/owst
[@seikichi]: https://github.com/seikichi
[@madwort]: https://github.com/madwort
[@annih]: https://github.com/annih
[@mmcguinn]: https://github.com/mmcguinn
[@pocke]: https://github.com/pocke
[@prsimp]: https://github.com/prsimp
[@ptarjan]: https://github.com/ptarjan
[@jweir]: https://github.com/jweir
[@Fryguy]: https://github.com/Fryguy
[@mikegee]: https://github.com/mikegee
[@tbrisker]: https://github.com/tbrisker
[@necojackarc]: https://github.com/necojackarc
rubocop-0.48.1+dfsg.orig/relnotes/v0.39.0.md 0000664 0000000 0000000 00000022336 13070542236 0020235 0 ustar 00root root 0000000 0000000 ### New features
* `Performance/TimesMap` cop can auto-correct. ([@lumeet][])
* `Style/ZeroLengthPredicate` cop can auto-correct. ([@lumeet][])
* [#2828](https://github.com/bbatsov/rubocop/issues/2828): `Style/ConditionalAssignment` is now configurable to enforce assignment inside of conditions or to enforce assignment to conditions. ([@rrosenblum][])
* [#2862](https://github.com/bbatsov/rubocop/pull/2862): `Performance/Detect` and `Performance/Count` have a new configuration `SafeMode` that is defaulted to `true`. These cops have known issues with `Rails` and other ORM frameworks. With this default configuration, these cops will not run if the `Rails` cops are enabled. ([@rrosenblum][])
* `Style/IfUnlessModifierOfIfUnless` cop added. ([@amuino][])
### Bug fixes
* [#2948](https://github.com/bbatsov/rubocop/issues/2948): `Style/SpaceAroundKeyword` should allow yield[n] and super[n]. ([@laurelfan][])
* [#2950](https://github.com/bbatsov/rubocop/issues/2950): Fix auto-correcting cases in which precedence has changed in `Style/OneLineConditional`. ([@lumeet][])
* [#2947](https://github.com/bbatsov/rubocop/issues/2947): Fix auto-correcting `if-then` in `Style/Next`. ([@lumeet][])
* [#2904](https://github.com/bbatsov/rubocop/issues/2904): `Style/RedundantParentheses` doesn't flag `-(1.method)` or `+(1.method)`, since removing the parentheses would change the meaning of these expressions. ([@alexdowad][])
* [#2958](https://github.com/bbatsov/rubocop/issues/2958): `Style/MultilineMethodCallIndentation` doesn't fail when inspecting unary ops which span multiple lines. ([@alexdowad][])
* [#2959](https://github.com/bbatsov/rubocop/issues/2959): `Lint/LiteralInInterpolation` doesn't report offenses for iranges and eranges with non-literal endpoints. ([@alexdowad][])
* [#2960](https://github.com/bbatsov/rubocop/issues/2960): `Lint/AssignmentInCondition` catches method assignments (like `obj.attr = val`) in a condition. ([@alexdowad][])
* [#2871](https://github.com/bbatsov/rubocop/issues/2871): Second solution for possible encoding incompatibility when outputting an HTML report. ([@jonas054][])
* [#2967](https://github.com/bbatsov/rubocop/pull/2967): Fix auto-correcting of `===`, `<=`, and `>=` in `Style/ConditionalAssignment`. ([@rrosenblum][])
* [#2977](https://github.com/bbatsov/rubocop/issues/2977): Fix auto-correcting of `"#{$!}"` in `Style/SpecialGlobalVars`. ([@lumeet][])
* [#2935](https://github.com/bbatsov/rubocop/issues/2935): Make configuration loading work if `SafeYAML.load` is private. ([@jonas054][])
### Changes
* `require:` only does relative includes when it starts with a `.`. ([@ptarjan][])
* `Style/IfUnlessModifier` does not trigger if the body is another conditional. ([@amuino][])
* [#2963](https://github.com/bbatsov/rubocop/pull/2963): `Performance/RedundantMerge` will now register an offense inside of `each_with_object`. ([@rrosenblum][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
[@tejasbubane]: https://github.com/tejasbubane
[@bmorrall]: https://github.com/bmorrall
[@fphilipe]: https://github.com/fphilipe
[@gotrevor]: https://github.com/gotrevor
[@awwaiid]: https://github.com/awwaiid
[@segiddins]: https://github.com/segiddins
[@urbanautomaton]: https://github.com/urbanautomaton.com
[@unmanbearpig]: https://github.com/unmanbearpig
[@maxjacobson]: https://github.com/maxjacobson
[@sliuu]: https://github.com/sliuu
[@edmz]: https://github.com/edmz
[@syndbg]: https://github.com/syndbg
[@wli]: https://github.com/wli
[@caseywebdev]: https://github.com/caseywebdev
[@MGerrior]: https://github.com/MGerrior
[@imtayadeway]: https://github.com/imtayadeway
[@mrfoto]: https://github.com/mrfoto
[@karreiro]: https://github.com/karreiro
[@dreyks]: https://github.com/dreyks
[@hmadison]: https://github.com/hmadison
[@miquella]: https://github.com/miquella
[@jhansche]: https://github.com/jhansche
[@cornelius]: https://github.com/cornelius
[@eagletmt]: https://github.com/eagletmt
[@apiology]: https://github.com/apiology
[@alexdowad]: https://github.com/alexdowad
[@minustehbare]: https://github.com/minustehbare
[@tansaku]: https://github.com/tansaku
[@ptrippett]: https://github.com/ptrippett
[@br3nda]: https://github.com/br3nda
[@jujugrrr]: https://github.com/jujugrrr
[@sometimesfood]: https://github.com/sometimesfood
[@cgriego]: https://github.com/cgriego
[@savef]: https://github.com/savef
[@volmer]: https://github.com/volmer
[@domcleal]: https://github.com/domcleal
[@codebeige]: https://github.com/codebeige
[@weh]: https://github.com/weh
[@bfontaine]: https://github.com/bfontaine
[@jawshooah]: https://github.com/jawshooah
[@DNNX]: https://github.com/DNNX
[@mvidner]: https://github.com/mvidner
[@mattparlane]: https://github.com/mattparlane
[@drenmi]: https://github.com/drenmi
[@stormbreakerbg]: https://github.com/stormbreakerbg
[@owst]: https://github.com/owst
[@seikichi]: https://github.com/seikichi
[@madwort]: https://github.com/madwort
[@annih]: https://github.com/annih
[@mmcguinn]: https://github.com/mmcguinn
[@pocke]: https://github.com/pocke
[@prsimp]: https://github.com/prsimp
[@ptarjan]: https://github.com/ptarjan
[@jweir]: https://github.com/jweir
[@Fryguy]: https://github.com/Fryguy
[@mikegee]: https://github.com/mikegee
[@tbrisker]: https://github.com/tbrisker
[@necojackarc]: https://github.com/necojackarc
[@laurelfan]: https://github.com/laurelfan
[@amuino]: https://github.com/amuino
rubocop-0.48.1+dfsg.orig/relnotes/v0.40.0.md 0000664 0000000 0000000 00000035065 13070542236 0020230 0 ustar 00root root 0000000 0000000 ### New features
* [#2997](https://github.com/bbatsov/rubocop/pull/2997): `Performance/CaseWhenSplat` can now identify multiple offenses in the same branch and offenses that do not occur as the first argument. ([@rrosenblum][])
* [#2928](https://github.com/bbatsov/rubocop/issues/2928): `Style/NestedParenthesizedCalls` cop can auto-correct. ([@drenmi][])
* `Style/RaiseArgs` cop can auto-correct. ([@drenmi][])
* [#2993](https://github.com/bbatsov/rubocop/pull/2993): `Style/SpaceAfterColon` now checks optional keyword arguments. ([@owst][])
* [#3003](https://github.com/bbatsov/rubocop/pull/3003): Read command line options from `.rubocop` file and `RUBOCOP_OPTS` environment variable. ([@bolshakov][])
* [#2857](https://github.com/bbatsov/rubocop/issues/2857): `Style/MultilineArrayBraceLayout` enforced style is configurable and supports `symmetrical` and `new_line` options. ([@panthomakos][])
* [#2857](https://github.com/bbatsov/rubocop/issues/2857): `Style/MultilineHashBraceLayout` enforced style is configurable and supports `symmetrical` and `new_line` options. ([@panthomakos][])
* [#2857](https://github.com/bbatsov/rubocop/issues/2857): `Style/MultilineMethodCallBraceLayout` enforced style is configurable and supports `symmetrical` and `new_line` options. ([@panthomakos][])
* [#2857](https://github.com/bbatsov/rubocop/issues/2857): `Style/MultilineMethodDefinitionBraceLayout` enforced style is configurable and supports `symmetrical` and `new_line` options. ([@panthomakos][])
* [#3052](https://github.com/bbatsov/rubocop/pull/3052): `Style/MultilineArrayBraceLayout` enforced style supports `same_line` option. ([@panthomakos][])
* [#3052](https://github.com/bbatsov/rubocop/pull/3052): `Style/MultilineHashBraceLayout` enforced style supports `same_line` option. ([@panthomakos][])
* [#3052](https://github.com/bbatsov/rubocop/pull/3052): `Style/MultilineMethodCallBraceLayout` enforced style supports `same_line` option. ([@panthomakos][])
* [#3052](https://github.com/bbatsov/rubocop/pull/3052): `Style/MultilineMethodDefinitionBraceLayout` enforced style supports `same_line` option. ([@panthomakos][])
* [#3019](https://github.com/bbatsov/rubocop/issues/3019): Add new `Style/EmptyCaseCondition` cop. ([@owst][], [@rrosenblum][])
* [#3072](https://github.com/bbatsov/rubocop/pull/3072): Add new `Lint/UselessArraySplat` cop. ([@owst][])
* [#3022](https://github.com/bbatsov/rubocop/issues/3022): `Style/Lambda` enforced style supports `literal` option. ([@drenmi][])
* [#2909](https://github.com/bbatsov/rubocop/issues/2909): `Style/Lambda` enforced style supports `lambda` option. ([@drenmi][])
* [#3092](https://github.com/bbatsov/rubocop/pull/3092): Allow `Style/Encoding` to enforce using no encoding comments. ([@NobodysNightmare][])
* New cop `Rails/UniqBeforePluck` checks that `uniq` is used before `pluck`. ([@tjwp][])
### Bug fixes
* [#3112](https://github.com/bbatsov/rubocop/issues/3112): Fix `Style/ClassAndModuleChildren` for nested classes with explicit superclass. ([@jspanjers][])
* [#3032](https://github.com/bbatsov/rubocop/issues/3032): Fix autocorrecting parentheses for predicate methods without space before args. ([@graemeboy][])
* [#3000](https://github.com/bbatsov/rubocop/pull/3000): Fix encoding crash on HTML output. ([@gerrywastaken][])
* [#2983](https://github.com/bbatsov/rubocop/pull/2983): `Style/AlignParameters` message was clarified for `with_fixed_indentation` style. ([@dylanahsmith][])
* [#2314](https://github.com/bbatsov/rubocop/pull/2314): Ignore `UnusedBlockArgument` for keyword arguments. ([@volkert][])
* [#2975](https://github.com/bbatsov/rubocop/issues/2975): Make comment indentation before `)` consistent with comment indentation before `}` or `]`. ([@jonas054][])
* [#3010](https://github.com/bbatsov/rubocop/issues/3010): Fix double reporting/correction of spaces after ternary operator colons (now only reported by `Style/SpaceAroundOperators`, and not `Style/SpaceAfterColon` too). ([@owst][])
* [#3006](https://github.com/bbatsov/rubocop/issues/3006): Register an offense for calling `merge!` on a method on a variable inside `each_with_object` in `Performance/RedundantMerge`. ([@lumeet][], [@rrosenblum][])
* [#2886](https://github.com/bbatsov/rubocop/issues/2886): Custom cop changes now bust the cache. ([@ptarjan][])
* [#3043](https://github.com/bbatsov/rubocop/issues/3043): `Style/SpaceAfterNot` will now register an offense for a receiver that is wrapped in parentheses. ([@rrosenblum][])
* [#3039](https://github.com/bbatsov/rubocop/issues/3039): Accept `match` without a receiver in `Performance/EndWith`. ([@lumeet][])
* [#3039](https://github.com/bbatsov/rubocop/issues/3039): Accept `match` without a receiver in `Performance/StartWith`. ([@lumeet][])
* [#3048](https://github.com/bbatsov/rubocop/issues/3048): `Lint/NestedMethodDefinition` shouldn't flag methods defined on Structs. ([@owst][])
* [#2912](https://github.com/bbatsov/rubocop/issues/2912): Check whether a line is aligned with the following line if the preceding line is not an assignment. ([@akihiro17][])
* [#3036](https://github.com/bbatsov/rubocop/issues/3036): Don't let `Lint/UnneededDisable` inspect files that are excluded for the cop. ([@jonas054][])
* [#2874](https://github.com/bbatsov/rubocop/issues/2874): Fix bug when the closing parenthesis is preceded by a newline in array and hash literals in `Style/RedundantParentheses`. ([@lumeet][])
* [#3049](https://github.com/bbatsov/rubocop/issues/3049): Make `Lint/UselessAccessModifier` detect conditionally defined methods and correctly handle dynamically defined methods and singleton class methods. ([@owst][])
* [#3004](https://github.com/bbatsov/rubocop/pull/3004): Don't add `Style/Alias` offenses for use of `alias` in `instance_eval` blocks, since object instances don't respond to `alias_method`. ([@magni-][])
* [#3061](https://github.com/bbatsov/rubocop/pull/3061): Custom cops now show up in --show-cops. ([@ptarjan][])
* [#3088](https://github.com/bbatsov/rubocop/pull/3088): Ignore offenses that involve conflicting HEREDOCs in the `Style/Multiline*BraceLayout` cops. ([@panthomakos][])
* [#3083](https://github.com/bbatsov/rubocop/issues/3083): Do not register an offense for splat block args in `Style/SymbolProc`. ([@rrosenblum][])
* [#3063](https://github.com/bbatsov/rubocop/issues/3063): Don't auto-correct `a + \` into `a + \\` in `Style/LineEndConcatenation`. ([@jonas054][])
* [#3034](https://github.com/bbatsov/rubocop/issues/3034): Report offenses for `RuntimeError.new(msg)` in `Style/RedundantException`. ([@jonas054][])
* [#3016](https://github.com/bbatsov/rubocop/issues/3016): `Style/SpaceAfterComma` now uses `Style/SpaceInsideHashLiteralBraces`'s setting. ([@ptarjan][])
### Changes
* [#2995](https://github.com/bbatsov/rubocop/issues/2995): Removed deprecated path matching syntax. ([@gerrywastaken][])
* [#3025](https://github.com/bbatsov/rubocop/pull/3025): Removed deprecation warnings for `rubocop-todo.yml`. ([@ptarjan][])
* [#3028](https://github.com/bbatsov/rubocop/pull/3028): Add `define_method` to the default list of `IgnoredMethods` of `Style/SymbolProc`. ([@jastkand][])
* [#3064](https://github.com/bbatsov/rubocop/pull/3064): `Style/SpaceAfterNot` highlights the entire expression instead of just the exlamation mark. ([@rrosenblum][])
* [#3085](https://github.com/bbatsov/rubocop/pull/3085): Enable `Style/MultilineArrayBraceLayout` and `Style/MultilineHashBraceLayout` with the `symmetrical` style by default. ([@panthomakos][])
* [#3091](https://github.com/bbatsov/rubocop/pull/3091): Enable `Style/MultilineMethodCallBraceLayout` and `Style/MultilineMethodDefinitionBraceLayout` with the `symmetrical` style by default. ([@panthomakos][])
* [#1830](https://github.com/bbatsov/rubocop/pull/1830): `Style/PredicateName` now ignores the `spec/` directory, since there is a strong convention for using `have_*` and `be_*` helper methods in RSpec. ([@gylaz][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
[@tejasbubane]: https://github.com/tejasbubane
[@bmorrall]: https://github.com/bmorrall
[@fphilipe]: https://github.com/fphilipe
[@gotrevor]: https://github.com/gotrevor
[@awwaiid]: https://github.com/awwaiid
[@segiddins]: https://github.com/segiddins
[@urbanautomaton]: https://github.com/urbanautomaton.com
[@unmanbearpig]: https://github.com/unmanbearpig
[@maxjacobson]: https://github.com/maxjacobson
[@sliuu]: https://github.com/sliuu
[@edmz]: https://github.com/edmz
[@syndbg]: https://github.com/syndbg
[@wli]: https://github.com/wli
[@caseywebdev]: https://github.com/caseywebdev
[@MGerrior]: https://github.com/MGerrior
[@imtayadeway]: https://github.com/imtayadeway
[@mrfoto]: https://github.com/mrfoto
[@karreiro]: https://github.com/karreiro
[@dreyks]: https://github.com/dreyks
[@hmadison]: https://github.com/hmadison
[@miquella]: https://github.com/miquella
[@jhansche]: https://github.com/jhansche
[@cornelius]: https://github.com/cornelius
[@eagletmt]: https://github.com/eagletmt
[@apiology]: https://github.com/apiology
[@alexdowad]: https://github.com/alexdowad
[@minustehbare]: https://github.com/minustehbare
[@tansaku]: https://github.com/tansaku
[@ptrippett]: https://github.com/ptrippett
[@br3nda]: https://github.com/br3nda
[@jujugrrr]: https://github.com/jujugrrr
[@sometimesfood]: https://github.com/sometimesfood
[@cgriego]: https://github.com/cgriego
[@savef]: https://github.com/savef
[@volmer]: https://github.com/volmer
[@domcleal]: https://github.com/domcleal
[@codebeige]: https://github.com/codebeige
[@weh]: https://github.com/weh
[@bfontaine]: https://github.com/bfontaine
[@jawshooah]: https://github.com/jawshooah
[@DNNX]: https://github.com/DNNX
[@mvidner]: https://github.com/mvidner
[@mattparlane]: https://github.com/mattparlane
[@drenmi]: https://github.com/drenmi
[@stormbreakerbg]: https://github.com/stormbreakerbg
[@owst]: https://github.com/owst
[@seikichi]: https://github.com/seikichi
[@madwort]: https://github.com/madwort
[@annih]: https://github.com/annih
[@mmcguinn]: https://github.com/mmcguinn
[@pocke]: https://github.com/pocke
[@prsimp]: https://github.com/prsimp
[@ptarjan]: https://github.com/ptarjan
[@jweir]: https://github.com/jweir
[@Fryguy]: https://github.com/Fryguy
[@mikegee]: https://github.com/mikegee
[@tbrisker]: https://github.com/tbrisker
[@necojackarc]: https://github.com/necojackarc
[@laurelfan]: https://github.com/laurelfan
[@amuino]: https://github.com/amuino
[@dylanahsmith]: https://github.com/dylanahsmith
[@gerrywastaken]: https://github.com/gerrywastaken
[@bolshakov]: https://github.com/bolshakov
[@jastkand]: https://github.com/jastkand
[@graemeboy]: https://github.com/graemeboy
[@akihiro17]: https://github.com/akihiro17
[@magni-]: https://github.com/magni-
[@NobodysNightmare]: https://github.com/NobodysNightmare
[@gylaz]: https://github.com/gylaz
[@tjwp]: https://github.com/tjwp
rubocop-0.48.1+dfsg.orig/relnotes/v0.41.0.md 0000664 0000000 0000000 00000037655 13070542236 0020240 0 ustar 00root root 0000000 0000000 ### New features
* [#2956](https://github.com/bbatsov/rubocop/issues/2956): Prefer `.ruby-version` to `TargetRubyVersion`. ([@pclalv][])
* [#3095](https://github.com/bbatsov/rubocop/issues/3095): Add `IndentationWidth` configuration parameter for `Style/AlignParameters` cop. ([@alexdowad][])
* [#3066](https://github.com/bbatsov/rubocop/issues/3066): Add new `Style/ImplicitRuntimeError` cop which advises the use of an explicit exception class when raising an error. ([@alexdowad][])
* [#3018](https://github.com/bbatsov/rubocop/issues/3018): Add new `Style/EachForSimpleLoop` cop which advises the use of `Integer#times` for simple loops which iterate a fixed number of times. ([@alexdowad][])
* [#2595](https://github.com/bbatsov/rubocop/issues/2595): New `compact` style for `Style/SpaceInsideLiteralHashBraces`. ([@alexdowad][])
* [#2927](https://github.com/bbatsov/rubocop/issues/2927): Add autocorrect for `Rails/Validation` cop. ([@neodelf][])
* [#3135](https://github.com/bbatsov/rubocop/pull/3135): Add new `Rails/OutputSafety` cop. ([@josh][])
* [#3164](https://github.com/bbatsov/rubocop/pull/3164): Add [Fastlane](https://fastlane.tools/)'s Fastfile to the default Includes. ([@jules2689][])
* [#3173](https://github.com/bbatsov/rubocop/pull/3173): Make `Style/ModuleFunction` configurable with `module_function` and `extend_self` styles. ([@tjwp][])
* [#3105](https://github.com/bbatsov/rubocop/issues/3105): Add new `Rails/RequestReferer` cop. ([@giannileggio][])
* [#3200](https://github.com/bbatsov/rubocop/pull/3200): Add autocorrect for `Style/EachForSimpleLoop` cop. ([@tejasbubane][])
* [#3058](https://github.com/bbatsov/rubocop/issues/3058): Add new `Style/SpaceInsideArrayPercentLiteral` cop. ([@owst][])
* [#3058](https://github.com/bbatsov/rubocop/issues/3058): Add new `Style/SpaceInsidePercentLiteralDelimiters` cop. ([@owst][])
* [#3179](https://github.com/bbatsov/rubocop/pull/3179): Expose files to support testings Cops using RSpec. ([@tjwp][])
* [#3191](https://github.com/bbatsov/rubocop/issues/3191): Allow arbitrary comments after cop names in CommentConfig lines (e.g. rubocop:enable). ([@owst][])
* [#3165](https://github.com/bbatsov/rubocop/pull/3165): Add new `Lint/PercentStringArray` cop. ([@owst][])
* [#3165](https://github.com/bbatsov/rubocop/pull/3165): Add new `Lint/PercentSymbolArray` cop. ([@owst][])
* [#3177](https://github.com/bbatsov/rubocop/pull/3177): Add new `Style/NumericLiteralPrefix` cop. ([@tejasbubane][])
* [#1646](https://github.com/bbatsov/rubocop/issues/1646): Add configuration style `indented_relative_to_receiver` for `Style/MultilineMethodCallIndentation`. ([@jonas054][])
* New cop `Lint/ShadowedException` checks for the order which exceptions are rescued to avoid rescueing a less specific exception before a more specific exception. ([@rrosenblum][])
* [#3127](https://github.com/bbatsov/rubocop/pull/3127): New cop `Lint/InheritException` checks for error classes inheriting from `Exception`, and instead suggests `RuntimeError` or `StandardError`. ([@drenmi][])
* Add new `Performance/PushSplat` cop. ([@segiddins][])
* [#3089](https://github.com/bbatsov/rubocop/issues/3089): Add new `Rails/Exit` cop. ([@sgringwe][])
### Bug fixes
* [#3005](https://github.com/bbatsov/rubocop/issues/3005): Symlink protection prevents use of caching in CI context. ([@urbanautomaton][])
* [#3037](https://github.com/bbatsov/rubocop/issues/3037): `Style/StringLiterals` understands that a bare '#', not '#@variable' or '#{interpolation}', does not require double quotes. ([@alexdowad][])
* [#2722](https://github.com/bbatsov/rubocop/issues/2722): `Style/ExtraSpacing` does not attempt to align an equals sign in an argument list with one in an assignment statement. ([@alexdowad][])
* [#3133](https://github.com/bbatsov/rubocop/issues/3133): `Style/MultilineMethodCallBraceLayout` does not register offenses for single-line calls. ([@alexdowad][])
* [#3170](https://github.com/bbatsov/rubocop/issues/3170): `Style/MutableConstant` does not infinite-loop when correcting an array with no brackets. ([@alexdowad][])
* [#3150](https://github.com/bbatsov/rubocop/issues/3150): Fix auto-correct for Style/MultilineArrayBraceLayout. ([@jspanjers][])
* [#3192](https://github.com/bbatsov/rubocop/pull/3192): Fix `Lint/UnusedBlockArgument`'s `IgnoreEmptyBlocks` parameter from being removed from configuration. ([@jfelchner][])
* [#3114](https://github.com/bbatsov/rubocop/issues/3114): Fix alignment `end` when auto-correcting `Style/EmptyElse`. ([@rrosenblum][])
* [#3120](https://github.com/bbatsov/rubocop/issues/3120): Fix `Lint/UselessAccessModifier` reporting useless access modifiers inside {Class,Module,Struct}.new blocks. ([@owst][])
* [#3125](https://github.com/bbatsov/rubocop/issues/3125): Fix `Rails/UniqBeforePluck` to ignore `uniq` with block. ([@tejasbubane][])
* [#3116](https://github.com/bbatsov/rubocop/issues/3116): `Style/SpaceAroundKeyword` allows `&.` method calls after `super` and `yield`. ([@segiddins][])
* [#3131](https://github.com/bbatsov/rubocop/issues/3131): Fix `Style/ZeroLengthPredicate` to ignore `size` and `length` variables. ([@tejasbubane][])
* [#3146](https://github.com/bbatsov/rubocop/pull/3146): Fix `NegatedIf` and `NegatedWhile` to ignore double negations. ([@natalzia-paperless][])
* [#3140](https://github.com/bbatsov/rubocop/pull/3140): `Style/FrozenStringLiteralComment` works with file doesn't have any tokens. ([@pocke][])
* [#3154](https://github.com/bbatsov/rubocop/issues/3154): Fix handling of `()` in `Style/RedundantParentheses`. ([@lumeet][])
* [#3155](https://github.com/bbatsov/rubocop/issues/3155): Fix `Style/SpaceAfterNot` reporting on the `not` keyword. ([@NobodysNightmare][])
* [#3160](https://github.com/bbatsov/rubocop/pull/3160): `Style/Lambda` fix whitespacing when auto-correcting unparenthesized arguments. ([@palkan][])
* [#2944](https://github.com/bbatsov/rubocop/issues/2944): Don't crash on strings that span multiple lines but only have one pair of delimiters in `Style/StringLiterals`. ([@jonas054][])
* [#3157](https://github.com/bbatsov/rubocop/issues/3157): Don't let `LineEndConcatenation` and `UnneededInterpolation` make changes to the same string during auto-correct. ([@jonas054][])
* [#3187](https://github.com/bbatsov/rubocop/issues/3187): Let `Style/BlockDelimiters` ignore blocks in *all* method arguments. ([@jonas054][])
* Modify `Style/ParallelAssignment` to use implicit begins when parallel assignment uses a `rescue` modifier and is the only thing in the method. ([@rrosenblum][])
* [#3217](https://github.com/bbatsov/rubocop/pull/3217): Fix output of ellipses for multi-line offense ranges in HTML formatter. ([@jonas054][])
* [#3207](https://github.com/bbatsov/rubocop/issues/3207): Auto-correct modifier `while`/`until` and `begin`..`end` + `while`/`until` in `Style/InfiniteLoop`. ([@jonas054][])
* [#3202](https://github.com/bbatsov/rubocop/issues/3202): Fix `Style/EmptyElse` registering wrong offenses and thus making RuboCop crash. ([@deivid-rodriguez][])
* [#3183](https://github.com/bbatsov/rubocop/issues/3183): Ensure `Style/SpaceInsideBlockBraces` reports offenses for multi-line blocks. ([@owst][])
* [#3017](https://github.com/bbatsov/rubocop/issues/3017): Fix `Style/StringLiterals` to register offenses on non-ascii strings. ([@deivid-rodriguez][])
* [#3056](https://github.com/bbatsov/rubocop/issues/3056): Fix `Style/StringLiterals` to register offenses on non-ascii strings. ([@deivid-rodriguez][])
* [#2986](https://github.com/bbatsov/rubocop/issues/2986): Fix `RedundantBlockCall` to not report calls that pass block arguments, or where the block has been overridden. ([@owst][])
* [#3223](https://github.com/bbatsov/rubocop/issues/3223): Return can take many arguments. ([@ptarjan][])
* [#3239](https://github.com/bbatsov/rubocop/pull/3239): Fix bug with --auto-gen-config and a file that does not exist. ([@meganemura][])
* [#3138](https://github.com/bbatsov/rubocop/issues/3138): Fix RuboCop crashing when config file contains utf-8 characters and external encoding is not utf-8. ([@deivid-rodriguez][])
* [#3175](https://github.com/bbatsov/rubocop/pull/3175): Generate 'Exclude' list for the cops with configurable enforced style to `.rubocop_todo.yml` if different styles are used. ([@flexoid][])
* [#3231](https://github.com/bbatsov/rubocop/pull/3231): Make `Rails/UniqBeforePluck` more conservative. ([@tjwp][])
### Changes
* [#3149](https://github.com/bbatsov/rubocop/pull/3149): Make `Style/HashSyntax` configurable to not report hash rocket syntax for symbols ending with ? or ! when using ruby19 style. ([@owst][])
* [#1758](https://github.com/bbatsov/rubocop/issues/1758): Let `Style/ClosingParenthesisIndentation` follow `Style/AlignParameters` configuration for method calls. ([@jonas054][])
* [#3224](https://github.com/bbatsov/rubocop/issues/3224): Rename `Style/DeprecatedHashMethods` to `Style/PreferredHashMethods`. ([@tejasbubane][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
[@tejasbubane]: https://github.com/tejasbubane
[@bmorrall]: https://github.com/bmorrall
[@fphilipe]: https://github.com/fphilipe
[@gotrevor]: https://github.com/gotrevor
[@awwaiid]: https://github.com/awwaiid
[@segiddins]: https://github.com/segiddins
[@urbanautomaton]: https://github.com/urbanautomaton.com
[@unmanbearpig]: https://github.com/unmanbearpig
[@maxjacobson]: https://github.com/maxjacobson
[@sliuu]: https://github.com/sliuu
[@edmz]: https://github.com/edmz
[@syndbg]: https://github.com/syndbg
[@wli]: https://github.com/wli
[@caseywebdev]: https://github.com/caseywebdev
[@MGerrior]: https://github.com/MGerrior
[@imtayadeway]: https://github.com/imtayadeway
[@mrfoto]: https://github.com/mrfoto
[@karreiro]: https://github.com/karreiro
[@dreyks]: https://github.com/dreyks
[@hmadison]: https://github.com/hmadison
[@miquella]: https://github.com/miquella
[@jhansche]: https://github.com/jhansche
[@cornelius]: https://github.com/cornelius
[@eagletmt]: https://github.com/eagletmt
[@apiology]: https://github.com/apiology
[@alexdowad]: https://github.com/alexdowad
[@minustehbare]: https://github.com/minustehbare
[@tansaku]: https://github.com/tansaku
[@ptrippett]: https://github.com/ptrippett
[@br3nda]: https://github.com/br3nda
[@jujugrrr]: https://github.com/jujugrrr
[@sometimesfood]: https://github.com/sometimesfood
[@cgriego]: https://github.com/cgriego
[@savef]: https://github.com/savef
[@volmer]: https://github.com/volmer
[@domcleal]: https://github.com/domcleal
[@codebeige]: https://github.com/codebeige
[@weh]: https://github.com/weh
[@bfontaine]: https://github.com/bfontaine
[@jawshooah]: https://github.com/jawshooah
[@DNNX]: https://github.com/DNNX
[@mvidner]: https://github.com/mvidner
[@mattparlane]: https://github.com/mattparlane
[@drenmi]: https://github.com/drenmi
[@stormbreakerbg]: https://github.com/stormbreakerbg
[@owst]: https://github.com/owst
[@seikichi]: https://github.com/seikichi
[@madwort]: https://github.com/madwort
[@annih]: https://github.com/annih
[@mmcguinn]: https://github.com/mmcguinn
[@pocke]: https://github.com/pocke
[@prsimp]: https://github.com/prsimp
[@ptarjan]: https://github.com/ptarjan
[@jweir]: https://github.com/jweir
[@Fryguy]: https://github.com/Fryguy
[@mikegee]: https://github.com/mikegee
[@tbrisker]: https://github.com/tbrisker
[@necojackarc]: https://github.com/necojackarc
[@laurelfan]: https://github.com/laurelfan
[@amuino]: https://github.com/amuino
[@dylanahsmith]: https://github.com/dylanahsmith
[@gerrywastaken]: https://github.com/gerrywastaken
[@bolshakov]: https://github.com/bolshakov
[@jastkand]: https://github.com/jastkand
[@graemeboy]: https://github.com/graemeboy
[@akihiro17]: https://github.com/akihiro17
[@magni-]: https://github.com/magni-
[@NobodysNightmare]: https://github.com/NobodysNightmare
[@gylaz]: https://github.com/gylaz
[@tjwp]: https://github.com/tjwp
[@neodelf]: https://github.com/neodelf
[@josh]: https://github.com/josh
[@natalzia-paperless]: https://github.com/natalzia-paperless
[@jules2689]: https://github.com/jules2689
[@giannileggio]: https://github.com/giannileggio
[@deivid-rodriguez]: https://github.com/deivid-rodriguez
[@pclalv]: https://github.com/pclalv
[@flexoid]: https://github.com/flexoid
[@sgringwe]: https://github.com/sgringwe
rubocop-0.48.1+dfsg.orig/relnotes/v0.41.2.md 0000664 0000000 0000000 00000022160 13070542236 0020223 0 ustar 00root root 0000000 0000000 ### Bug fixes
* [#3248](https://github.com/bbatsov/rubocop/issues/3248): Support 'ruby-' prefix in `.ruby-version`. ([@tjwp][])
* [#3250](https://github.com/bbatsov/rubocop/pull/3250): Make regexp for cop names less restrictive in CommentConfig lines. ([@tjwp][])
* [#3261](https://github.com/bbatsov/rubocop/pull/3261): Prefer `TargetRubyVersion` to `.ruby-version`. ([@tjwp][])
* [#3249](https://github.com/bbatsov/rubocop/issues/3249): Account for `rescue nil` in `Style/ShadowedException`. ([@rrosenblum][])
* Modify the highlighting in `Style/ShadowedException` to be more useful. Highlight just `rescue` area. ([@rrosenblum][])
* [#3129](https://github.com/bbatsov/rubocop/issues/3129): Fix `Style/MethodCallParentheses` to work with multiple assignments. ([@tejasbubane][])
* [#3247](https://github.com/bbatsov/rubocop/issues/3247): Ensure whitespace after beginning of block in `Style/BlockDelimiters`. ([@tjwp][])
* [#2941](https://github.com/bbatsov/rubocop/issues/2941): Make sure `Lint/UnneededDisable` can do auto-correction. ([@jonas054][])
* [#3269](https://github.com/bbatsov/rubocop/pull/3269): Fix `Lint/ShadowedException` to block arbitrary code execution. ([@pocke][])
* [#3266](https://github.com/bbatsov/rubocop/issues/3266): Handle empty parentheses in `Performance/RedundantBlockCall` auto-correct. ([@jonas054][])
* [#3272](https://github.com/bbatsov/rubocop/issues/3272): Add escape character missing to LITERAL_REGEX. ([@pocke][])
* [#3255](https://github.com/bbatsov/rubocop/issues/3255): Fix auto-correct for `Style/RaiseArgs` when constructing exception without arguments. ([@drenmi][])
* [#3294](https://github.com/bbatsov/rubocop/pull/3294): Allow to use `Time.zone_default`. ([@Tei][])
### Changes
* [#3230](https://github.com/bbatsov/rubocop/issues/3230): Improve highlighting for `Style/AsciiComments` cop. ([@drenmi][])
* Improve highlighting for `Style/AsciiIdentifiers` cop. ([@drenmi][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
[@tejasbubane]: https://github.com/tejasbubane
[@bmorrall]: https://github.com/bmorrall
[@fphilipe]: https://github.com/fphilipe
[@gotrevor]: https://github.com/gotrevor
[@awwaiid]: https://github.com/awwaiid
[@segiddins]: https://github.com/segiddins
[@urbanautomaton]: https://github.com/urbanautomaton.com
[@unmanbearpig]: https://github.com/unmanbearpig
[@maxjacobson]: https://github.com/maxjacobson
[@sliuu]: https://github.com/sliuu
[@edmz]: https://github.com/edmz
[@syndbg]: https://github.com/syndbg
[@wli]: https://github.com/wli
[@caseywebdev]: https://github.com/caseywebdev
[@MGerrior]: https://github.com/MGerrior
[@imtayadeway]: https://github.com/imtayadeway
[@mrfoto]: https://github.com/mrfoto
[@karreiro]: https://github.com/karreiro
[@dreyks]: https://github.com/dreyks
[@hmadison]: https://github.com/hmadison
[@miquella]: https://github.com/miquella
[@jhansche]: https://github.com/jhansche
[@cornelius]: https://github.com/cornelius
[@eagletmt]: https://github.com/eagletmt
[@apiology]: https://github.com/apiology
[@alexdowad]: https://github.com/alexdowad
[@minustehbare]: https://github.com/minustehbare
[@tansaku]: https://github.com/tansaku
[@ptrippett]: https://github.com/ptrippett
[@br3nda]: https://github.com/br3nda
[@jujugrrr]: https://github.com/jujugrrr
[@sometimesfood]: https://github.com/sometimesfood
[@cgriego]: https://github.com/cgriego
[@savef]: https://github.com/savef
[@volmer]: https://github.com/volmer
[@domcleal]: https://github.com/domcleal
[@codebeige]: https://github.com/codebeige
[@weh]: https://github.com/weh
[@bfontaine]: https://github.com/bfontaine
[@jawshooah]: https://github.com/jawshooah
[@DNNX]: https://github.com/DNNX
[@mvidner]: https://github.com/mvidner
[@mattparlane]: https://github.com/mattparlane
[@drenmi]: https://github.com/drenmi
[@stormbreakerbg]: https://github.com/stormbreakerbg
[@owst]: https://github.com/owst
[@seikichi]: https://github.com/seikichi
[@madwort]: https://github.com/madwort
[@annih]: https://github.com/annih
[@mmcguinn]: https://github.com/mmcguinn
[@pocke]: https://github.com/pocke
[@prsimp]: https://github.com/prsimp
[@ptarjan]: https://github.com/ptarjan
[@jweir]: https://github.com/jweir
[@Fryguy]: https://github.com/Fryguy
[@mikegee]: https://github.com/mikegee
[@tbrisker]: https://github.com/tbrisker
[@necojackarc]: https://github.com/necojackarc
[@laurelfan]: https://github.com/laurelfan
[@amuino]: https://github.com/amuino
[@dylanahsmith]: https://github.com/dylanahsmith
[@gerrywastaken]: https://github.com/gerrywastaken
[@bolshakov]: https://github.com/bolshakov
[@jastkand]: https://github.com/jastkand
[@graemeboy]: https://github.com/graemeboy
[@akihiro17]: https://github.com/akihiro17
[@magni-]: https://github.com/magni-
[@NobodysNightmare]: https://github.com/NobodysNightmare
[@gylaz]: https://github.com/gylaz
[@tjwp]: https://github.com/tjwp
[@neodelf]: https://github.com/neodelf
[@josh]: https://github.com/josh
[@natalzia-paperless]: https://github.com/natalzia-paperless
[@jules2689]: https://github.com/jules2689
[@giannileggio]: https://github.com/giannileggio
[@deivid-rodriguez]: https://github.com/deivid-rodriguez
[@pclalv]: https://github.com/pclalv
[@flexoid]: https://github.com/flexoid
[@sgringwe]: https://github.com/sgringwe
[@Tei]: https://github.com/Tei
rubocop-0.48.1+dfsg.orig/relnotes/v0.42.0.md 0000664 0000000 0000000 00000023100 13070542236 0020215 0 ustar 00root root 0000000 0000000 ### New features
* [#3306](https://github.com/bbatsov/rubocop/issues/3306): Add autocorrection for `Style/EachWithObject`. ([@owst][])
* Add new `Style/TernaryParentheses` cop. ([@drenmi][])
* [#3136](https://github.com/bbatsov/rubocop/issues/3136): Add config for `UselessAccessModifier` so it can be made aware of ActiveSupport's `concerning` and `class_methods` methods. ([@maxjacobson][])
* [#3128](https://github.com/bbatsov/rubocop/issues/3128): Add new `Rails/SaveBang` cop. ([@QuinnHarris][])
### Bug fixes
* [#3271](https://github.com/bbatsov/rubocop/issues/3271): Fix bad auto-correct for `Style/EachForSimpleLoop` cop. ([@drenmi][])
* [#3288](https://github.com/bbatsov/rubocop/issues/3288): Fix auto-correct of word and symbol arrays in `Style/ParallelAssignment` cop. ([@jonas054][])
* [#3307](https://github.com/bbatsov/rubocop/issues/3307): Fix exception when inspecting an operator assignment with `Style/MethodCallParentheses` cop. ([@drenmi][])
* [#3316](https://github.com/bbatsov/rubocop/issues/3316): Fix error for blocks without arguments in `Style/SingleLineBlockParams` cop. ([@owst][])
* [#3320](https://github.com/bbatsov/rubocop/issues/3320): Make `Style/OpMethod` aware of the backtick method. ([@drenmi][])
* Do not register an offense in `Lint/ShadowedException` when rescuing an exception built into Ruby before a custom exception. ([@rrosenblum][])
### Changes
* [#2645](https://github.com/bbatsov/rubocop/issues/2645): `Style/EmptyLiteral` no longer generates an offense for `String.new` when using frozen string literals. ([@drenmi][])
* [#3308](https://github.com/bbatsov/rubocop/issues/3308): Make `Lint/NextWithoutAccumulator` aware of nested enumeration. ([@drenmi][])
* Extend `Style/MethodMissing` cop to check for the conditions in the style guide. ([@drenmi][])
* [#3325](https://github.com/bbatsov/rubocop/issues/3325): Drop support for MRI 1.9.3. ([@drenmi][])
* Add support for MRI 2.4. ([@dvandersluis][])
* [#3256](https://github.com/bbatsov/rubocop/issues/3256): Highlight the closing brace in `Style/Multiline...BraceLayout` cops. ([@jonas054][])
* Always register an offense when rescuing `Exception` before or along with any other exception in `Lint/ShadowedException`. ([@rrosenblum][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
[@tejasbubane]: https://github.com/tejasbubane
[@bmorrall]: https://github.com/bmorrall
[@fphilipe]: https://github.com/fphilipe
[@gotrevor]: https://github.com/gotrevor
[@awwaiid]: https://github.com/awwaiid
[@segiddins]: https://github.com/segiddins
[@urbanautomaton]: https://github.com/urbanautomaton.com
[@unmanbearpig]: https://github.com/unmanbearpig
[@maxjacobson]: https://github.com/maxjacobson
[@sliuu]: https://github.com/sliuu
[@edmz]: https://github.com/edmz
[@syndbg]: https://github.com/syndbg
[@wli]: https://github.com/wli
[@caseywebdev]: https://github.com/caseywebdev
[@MGerrior]: https://github.com/MGerrior
[@imtayadeway]: https://github.com/imtayadeway
[@mrfoto]: https://github.com/mrfoto
[@karreiro]: https://github.com/karreiro
[@dreyks]: https://github.com/dreyks
[@hmadison]: https://github.com/hmadison
[@miquella]: https://github.com/miquella
[@jhansche]: https://github.com/jhansche
[@cornelius]: https://github.com/cornelius
[@eagletmt]: https://github.com/eagletmt
[@apiology]: https://github.com/apiology
[@alexdowad]: https://github.com/alexdowad
[@minustehbare]: https://github.com/minustehbare
[@tansaku]: https://github.com/tansaku
[@ptrippett]: https://github.com/ptrippett
[@br3nda]: https://github.com/br3nda
[@jujugrrr]: https://github.com/jujugrrr
[@sometimesfood]: https://github.com/sometimesfood
[@cgriego]: https://github.com/cgriego
[@savef]: https://github.com/savef
[@volmer]: https://github.com/volmer
[@domcleal]: https://github.com/domcleal
[@codebeige]: https://github.com/codebeige
[@weh]: https://github.com/weh
[@bfontaine]: https://github.com/bfontaine
[@jawshooah]: https://github.com/jawshooah
[@DNNX]: https://github.com/DNNX
[@mvidner]: https://github.com/mvidner
[@mattparlane]: https://github.com/mattparlane
[@drenmi]: https://github.com/drenmi
[@stormbreakerbg]: https://github.com/stormbreakerbg
[@owst]: https://github.com/owst
[@seikichi]: https://github.com/seikichi
[@madwort]: https://github.com/madwort
[@annih]: https://github.com/annih
[@mmcguinn]: https://github.com/mmcguinn
[@pocke]: https://github.com/pocke
[@prsimp]: https://github.com/prsimp
[@ptarjan]: https://github.com/ptarjan
[@jweir]: https://github.com/jweir
[@Fryguy]: https://github.com/Fryguy
[@mikegee]: https://github.com/mikegee
[@tbrisker]: https://github.com/tbrisker
[@necojackarc]: https://github.com/necojackarc
[@laurelfan]: https://github.com/laurelfan
[@amuino]: https://github.com/amuino
[@dylanahsmith]: https://github.com/dylanahsmith
[@gerrywastaken]: https://github.com/gerrywastaken
[@bolshakov]: https://github.com/bolshakov
[@jastkand]: https://github.com/jastkand
[@graemeboy]: https://github.com/graemeboy
[@akihiro17]: https://github.com/akihiro17
[@magni-]: https://github.com/magni-
[@NobodysNightmare]: https://github.com/NobodysNightmare
[@gylaz]: https://github.com/gylaz
[@tjwp]: https://github.com/tjwp
[@neodelf]: https://github.com/neodelf
[@josh]: https://github.com/josh
[@natalzia-paperless]: https://github.com/natalzia-paperless
[@jules2689]: https://github.com/jules2689
[@giannileggio]: https://github.com/giannileggio
[@deivid-rodriguez]: https://github.com/deivid-rodriguez
[@pclalv]: https://github.com/pclalv
[@flexoid]: https://github.com/flexoid
[@sgringwe]: https://github.com/sgringwe
[@Tei]: https://github.com/Tei
[@haziqhafizuddin]: https://github.com/haziqhafizuddin
[@dvandersluis]: https://github.com/dvandersluis
[@QuinnHarris]: https://github.com/QuinnHarris
rubocop-0.48.1+dfsg.orig/relnotes/v0.43.0.md 0000664 0000000 0000000 00000033555 13070542236 0020235 0 ustar 00root root 0000000 0000000 ## 0.43.0 (2016-09-19)
### New features
* [#3379](https://github.com/bbatsov/rubocop/issues/3379): Add table of contents at the beginning of HTML formatted output. ([@hedgesky][])
* [#2968](https://github.com/bbatsov/rubocop/issues/2968): Add new `Style/DocumentationMethod` cop. ([@sooyang][])
* [#3360](https://github.com/bbatsov/rubocop/issues/3360): Add `RequireForNonPublicMethods` configuration option to `Style/DocumentationMethod` cop. ([@drenmi][])
* Add new `Rails/SafeNavigation` cop to convert `try!` to `&.`. ([@rrosenblum][])
* [#3415](https://github.com/bbatsov/rubocop/pull/3415): Add new `Rails/NotNullColumn` cop. ([@pocke][])
* [#3167](https://github.com/bbatsov/rubocop/issues/3167): Add new `Style/VariableNumber` cop. ([@sooyang][])
* Add new style `no_mixed_keys` to `Style/HashSyntax` to only check for hashes with mixed keys. ([@daviddavis][])
* Allow including multiple configuration files from a single gem. ([@tjwallace][])
* Add check for `persisted?` method call when using a create method in `Rails/SaveBang`. ([@QuinnHarris][])
* Add new `Style/SafeNavigation` cop to convert method calls safeguarded by a non `nil` check for the object to `&.`. ([@rrosenblum][])
* Add new `Performance/SortWithBlock` cop to use `sort_by(&:foo)` instead of `sort_by { |a, b| a.foo <=> b.foo }`. ([@koic][])
* [#3492](https://github.com/bbatsov/rubocop/pull/3492): Add new `UnifiedInteger` cop. ([@pocke][])
### Bug fixes
* [#3383](https://github.com/bbatsov/rubocop/issues/3383): Fix the local variable reset issue with `Style/RedundantSelf` cop. ([@bankair][])
* [#3445](https://github.com/bbatsov/rubocop/issues/3445): Fix bad autocorrect for `Style/AndOr` cop. ([@mikezter][])
* [#3349](https://github.com/bbatsov/rubocop/issues/3349): Fix bad autocorrect for `Style/Lambda` cop. ([@metcalf][])
* [#3351](https://github.com/bbatsov/rubocop/issues/3351): Fix bad auto-correct for `Performance/RedundantMatch` cop. ([@annaswims][])
* [#3347](https://github.com/bbatsov/rubocop/issues/3347): Prevent infinite loop in `Style/TernaryParentheses` cop when used together with `Style/RedundantParentheses`. ([@drenmi][])
* [#3209](https://github.com/bbatsov/rubocop/issues/3209): Remove faulty line length check from `Style/GuardClause` cop. ([@drenmi][])
* [#3366](https://github.com/bbatsov/rubocop/issues/3366): Make `Style/MutableConstant` cop aware of splat assignments. ([@drenmi][])
* [#3372](https://github.com/bbatsov/rubocop/pull/3372): Fix RuboCop crash with empty brackets in `Style/Next` cop. ([@pocke][])
* [#3358](https://github.com/bbatsov/rubocop/issues/3358): Make `Style/MethodMissing` cop aware of class scope. ([@drenmi][])
* [#3342](https://github.com/bbatsov/rubocop/issues/3342): Fix error in `Lint/ShadowedException` cop if last rescue does not have parameter. ([@soutaro][])
* [#3380](https://github.com/bbatsov/rubocop/issues/3380): Fix false positive in `Style/TrailingUnderscoreVariable` cop. ([@drenmi][])
* [#3388](https://github.com/bbatsov/rubocop/issues/3388): Fix bug where `Lint/ShadowedException` would register an offense when rescuing different numbers of custom exceptions in multiple rescue groups. ([@rrosenblum][])
* [#3386](https://github.com/bbatsov/rubocop/issues/3386): Make `VariableForce` understand an empty RegExp literal as LHS to `=~`. ([@drenmi][])
* [#3421](https://github.com/bbatsov/rubocop/pull/3421): Fix clobbering `inherit_from` additions when not using Namespaces in the configs. ([@nicklamuro][])
* [#3425](https://github.com/bbatsov/rubocop/pull/3425): Fix bug for invalid bytes in UTF-8 in `Lint/PercentStringArray` cop. ([@pocke][])
* [#3374](https://github.com/bbatsov/rubocop/issues/3374): Make `SpaceInsideBlockBraces` and `SpaceBeforeBlockBraces` not depend on `BlockDelimiters` configuration. ([@jonas054][])
* Fix error in `Lint/ShadowedException` cop for higher number of rescue groups. ([@groddeck][])
* [#3456](https://github.com/bbatsov/rubocop/pull/3456): Don't crash on a multiline empty brace in `Style/MultilineMethodCallBraceLayout`. ([@pocke][])
* [#3423](https://github.com/bbatsov/rubocop/issues/3423): Checks if .rubocop is a file before parsing. ([@joejuzl][])
* [#3439](https://github.com/bbatsov/rubocop/issues/3439): Fix variable assignment check not working properly when a block is used in `Rails/SaveBang`. ([@QuinnHarris][])
* [#3401](https://github.com/bbatsov/rubocop/issues/3401): Read file contents in binary mode so `Style/EndOfLine` works on Windows. ([@jonas054][])
* [#3450](https://github.com/bbatsov/rubocop/issues/3450): Prevent `Style/TernaryParentheses` cop from making unsafe corrections. ([@drenmi][])
* [#3460](https://github.com/bbatsov/rubocop/issues/3460): Fix false positives in `Style/InlineComment` cop. ([@drenmi][])
* [#3485](https://github.com/bbatsov/rubocop/issues/3485): Make OneLineConditional cop not register offense for empty else. ([@tejasbubane][])
* [#3508](https://github.com/bbatsov/rubocop/pull/3508): Fix false negatives in `Rails/NotNullColumn`. ([@pocke][])
* [#3462](https://github.com/bbatsov/rubocop/issues/3462): Don't create MultilineMethodCallBraceLayout offenses for single-line method calls when receiver spans multiple lines. ([@maxjacobson][])
### Changes
* [#3341](https://github.com/bbatsov/rubocop/issues/3341): Exclude RSpec tests from inspection by `Style/NumericPredicate` cop. ([@drenmi][])
* Rename `Lint/UselessArraySplat` to `Lint/UnneededSplatExpansion`, and add functionality to check for unnecessary expansion of other literals. ([@rrosenblum][])
* No longer register an offense for splat expansion of an array literal in `Performance/CaseWhenSplat`. `Lint/UnneededSplatExpansion` now handles this behavior. ([@rrosenblum][])
* `Lint/InheritException` restricts inheriting from standard library subclasses of `Exception`. ([@metcalf][])
* No longer register an offense if the first line of code starts with `#\` in `Style/LeadingCommentSpace`. `config.ru` files consider such lines as options. ([@scottohara][])
* [#3292](https://github.com/bbatsov/rubocop/issues/3292): Remove `Performance/PushSplat` as it can produce code that is slower or even cause failure. ([@jonas054][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
[@tejasbubane]: https://github.com/tejasbubane
[@bmorrall]: https://github.com/bmorrall
[@fphilipe]: https://github.com/fphilipe
[@gotrevor]: https://github.com/gotrevor
[@awwaiid]: https://github.com/awwaiid
[@segiddins]: https://github.com/segiddins
[@urbanautomaton]: https://github.com/urbanautomaton.com
[@unmanbearpig]: https://github.com/unmanbearpig
[@maxjacobson]: https://github.com/maxjacobson
[@sliuu]: https://github.com/sliuu
[@edmz]: https://github.com/edmz
[@syndbg]: https://github.com/syndbg
[@wli]: https://github.com/wli
[@caseywebdev]: https://github.com/caseywebdev
[@MGerrior]: https://github.com/MGerrior
[@imtayadeway]: https://github.com/imtayadeway
[@mrfoto]: https://github.com/mrfoto
[@karreiro]: https://github.com/karreiro
[@dreyks]: https://github.com/dreyks
[@hmadison]: https://github.com/hmadison
[@miquella]: https://github.com/miquella
[@jhansche]: https://github.com/jhansche
[@cornelius]: https://github.com/cornelius
[@eagletmt]: https://github.com/eagletmt
[@apiology]: https://github.com/apiology
[@alexdowad]: https://github.com/alexdowad
[@minustehbare]: https://github.com/minustehbare
[@tansaku]: https://github.com/tansaku
[@ptrippett]: https://github.com/ptrippett
[@br3nda]: https://github.com/br3nda
[@jujugrrr]: https://github.com/jujugrrr
[@sometimesfood]: https://github.com/sometimesfood
[@cgriego]: https://github.com/cgriego
[@savef]: https://github.com/savef
[@volmer]: https://github.com/volmer
[@domcleal]: https://github.com/domcleal
[@codebeige]: https://github.com/codebeige
[@weh]: https://github.com/weh
[@bfontaine]: https://github.com/bfontaine
[@jawshooah]: https://github.com/jawshooah
[@DNNX]: https://github.com/DNNX
[@mvidner]: https://github.com/mvidner
[@mattparlane]: https://github.com/mattparlane
[@drenmi]: https://github.com/drenmi
[@stormbreakerbg]: https://github.com/stormbreakerbg
[@owst]: https://github.com/owst
[@seikichi]: https://github.com/seikichi
[@madwort]: https://github.com/madwort
[@annih]: https://github.com/annih
[@mmcguinn]: https://github.com/mmcguinn
[@pocke]: https://github.com/pocke
[@prsimp]: https://github.com/prsimp
[@ptarjan]: https://github.com/ptarjan
[@jweir]: https://github.com/jweir
[@Fryguy]: https://github.com/Fryguy
[@mikegee]: https://github.com/mikegee
[@tbrisker]: https://github.com/tbrisker
[@necojackarc]: https://github.com/necojackarc
[@laurelfan]: https://github.com/laurelfan
[@amuino]: https://github.com/amuino
[@dylanahsmith]: https://github.com/dylanahsmith
[@gerrywastaken]: https://github.com/gerrywastaken
[@bolshakov]: https://github.com/bolshakov
[@jastkand]: https://github.com/jastkand
[@graemeboy]: https://github.com/graemeboy
[@akihiro17]: https://github.com/akihiro17
[@magni-]: https://github.com/magni-
[@NobodysNightmare]: https://github.com/NobodysNightmare
[@gylaz]: https://github.com/gylaz
[@tjwp]: https://github.com/tjwp
[@neodelf]: https://github.com/neodelf
[@josh]: https://github.com/josh
[@natalzia-paperless]: https://github.com/natalzia-paperless
[@jules2689]: https://github.com/jules2689
[@giannileggio]: https://github.com/giannileggio
[@deivid-rodriguez]: https://github.com/deivid-rodriguez
[@pclalv]: https://github.com/pclalv
[@flexoid]: https://github.com/flexoid
[@sgringwe]: https://github.com/sgringwe
[@Tei]: https://github.com/Tei
[@haziqhafizuddin]: https://github.com/haziqhafizuddin
[@dvandersluis]: https://github.com/dvandersluis
[@QuinnHarris]: https://github.com/QuinnHarris
[@sooyang]: https://github.com/sooyang
[@metcalf]: https://github.com/metcalf
[@annaswims]: https://github.com/annaswims
[@soutaro]: https://github.com/soutaro
[@nicklamuro]: https://github.com/nicklamuro
[@mikezter]: https://github.com/mikezter
[@joejuzl]: https://github.com/joejuzl
[@hedgesky]: https://github.com/hedgesky
[@tjwallace]: https://github.com/tjwallace
[@scottohara]: https://github.com/scottohara
[@koic]: https://github.com/koic
[@groddeck]: https://github.com/groddeck
rubocop-0.48.1+dfsg.orig/relnotes/v0.44.0.md 0000664 0000000 0000000 00000034147 13070542236 0020234 0 ustar 00root root 0000000 0000000 ### New features
* [#3560](https://github.com/bbatsov/rubocop/pull/3560): Add a configuration option `empty_lines_except_namespace` to `Style/EmptyLinesAroundClassBody` and `Style/EmptyLinesAroundModuleBody`. ([@legendetm][])
* [#3370](https://github.com/bbatsov/rubocop/issues/3370): Add new `Rails/HttpPositionalArguments` cop to check your Rails 5 test code for existence of positional args usage. ([@logicminds][])
* [#3510](https://github.com/bbatsov/rubocop/issues/3510): Add a configuration option, `ConvertCodeThatCanStartToReturnNil`, to `Style/SafeNavigation` to check for code that could start returning `nil` if safe navigation is used. ([@rrosenblum][])
* Add a new `AllCops/StyleGuideBaseURL` setting that allows the use of relative paths and/or fragments within each cop's `StyleGuide` setting, to make forking of custom style guides easier. ([@scottmatthewman][])
* [#3566](https://github.com/bbatsov/rubocop/issues/3566): Add new `Metric/BlockLength` cop to ensure blocks don't get too long. ([@savef][])
* [#3428](https://github.com/bbatsov/rubocop/issues/3428): Add support for configuring `Style/PreferredHashMethods` with either `short` or `verbose` style method names. ([@abrom][])
* [#3455](https://github.com/bbatsov/rubocop/issues/3455): Add new `Rails/DynamicFindBy` cop. ([@pocke][])
* [#3542](https://github.com/bbatsov/rubocop/issues/3542): Add a configuration option, `IgnoreCopDirectives`, to `Metrics/LineLength` to stop cop directives (`# rubocop:disable Metrics/AbcSize`) from being counted when considering line length. ([@jmks][])
* Add new `Rails/DelegateAllowBlank` cop. ([@connorjacobsen][])
* Add new `Style/MultilineMemoization` cop. ([@drenmi][])
### Bug fixes
* [#3103](https://github.com/bbatsov/rubocop/pull/3103): Make `Style/ExtraSpacing` cop register an offense for extra spaces present in single-line hash literals. ([@tcdowney][])
* [#3513](https://github.com/bbatsov/rubocop/pull/3513): Fix false positive in `Style/TernaryParentheses` for a ternary with ranges. ([@dreyks][])
* [#3520](https://github.com/bbatsov/rubocop/issues/3520): Fix regression causing `Lint/AssignmentInCondition` false positive. ([@savef][])
* [#3514](https://github.com/bbatsov/rubocop/issues/3514): Make `Style/VariableNumber` cop not register an offense when valid normal case variable names have an integer after the first `_`. ([@b-t-g][])
* [#3516](https://github.com/bbatsov/rubocop/issues/3516): Make `Style/VariableNumber` cop not register an offense when valid normal case variable names have an integer in the middle. ([@b-t-g][])
* [#3436](https://github.com/bbatsov/rubocop/issues/3436): Make `Rails/SaveBang` cop not register an offense when return value of a non-bang method is returned by the parent method. ([@coorasse][])
* [#3540](https://github.com/bbatsov/rubocop/issues/3540): Fix `Style/GuardClause` to register offense for instance and singleton methods. ([@tejasbubane][])
* [#3311](https://github.com/bbatsov/rubocop/issues/3311): Detect incompatibilities with the external encoding to prevent bad autocorrections in `Style/StringLiterals`. ([@deivid-rodriguez][])
* [#3499](https://github.com/bbatsov/rubocop/issues/3499): Ensure `Lint/UnusedBlockArgument` doesn't make recommendations that would change arity for methods defined using `#define_method`. ([@drenmi][])
* [#3430](https://github.com/bbatsov/rubocop/issues/3430): Fix exception in `Performance/RedundantMerge` when inspecting a `#merge!` with implicit receiver. ([@drenmi][])
* [#3411](https://github.com/bbatsov/rubocop/issues/3411): Avoid auto-correction crash for single `when` in `Performance/CaseWhenSplat`. ([@jonas054][])
* [#3286](https://github.com/bbatsov/rubocop/issues/3286): Allow `self.a, self.b = b, a` in `Style/ParallelAssignment`. ([@jonas054][])
* [#3419](https://github.com/bbatsov/rubocop/issues/3419): Report offense for `unless x.nil?` in `Style/NonNilCheck` if `IncludeSemanticChanges` is `true`. ([@jonas054][])
* [#3382](https://github.com/bbatsov/rubocop/issues/3382): Avoid auto-correction crash for multiple elsifs in `Style/EmptyElse`. ([@lumeet][])
* [#3334](https://github.com/bbatsov/rubocop/issues/3334): Do not register an offense for a literal space (`\s`) in `Style/UnneededCapitalW`. ([@rrosenblum][])
* [#3390](https://github.com/bbatsov/rubocop/issues/3390): Fix SaveBang cop for multiple conditional. ([@tejasbubane][])
* [#3577](https://github.com/bbatsov/rubocop/issues/3577): Fix `Style/RaiseArgs` not allowing compact raise with splatted args. ([@savef][])
* [#3578](https://github.com/bbatsov/rubocop/issues/3578): Fix safe navigation method call counting in `Metrics/AbcSize`. ([@savef][])
* [#3592](https://github.com/bbatsov/rubocop/issues/3592): Fix `Style/RedundantParentheses` for indexing with literals. ([@thegedge][])
* [#3597](https://github.com/bbatsov/rubocop/issues/3597): Fix the autocorrect of `Performance/CaseWhenSplat` when trying to rearange splat expanded variables to the end of a when condition. ([@rrosenblum][])
### Changes
* [#3512](https://github.com/bbatsov/rubocop/issues/3512): Change error message of `Lint/UnneededSplatExpansion` for array in method parameters. ([@tejasbubane][])
* [#3510](https://github.com/bbatsov/rubocop/issues/3510): Fix some issues with `Style/SafeNavigation`. Fix auto-correct of multiline if expressions, and do not register an offense for scenarios using `||` and ternary expression. ([@rrosenblum][])
* [#3503](https://github.com/bbatsov/rubocop/issues/3503): Change misleading message of `Style/EmptyLinesAroundAccessModifier`. ([@bquorning][])
* [#3407](https://github.com/bbatsov/rubocop/issues/3407): Turn off autocorrect for unsafe rules by default. ([@ptarjan][])
* [#3521](https://github.com/bbatsov/rubocop/issues/3521): Turn off autocorrect for `Security/JSONLoad` by default. ([@savef][])
* [#2903](https://github.com/bbatsov/rubocop/issues/2903): `Style/RedundantReturn` looks for redundant `return` inside conditional branches. ([@lumeet][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
[@tejasbubane]: https://github.com/tejasbubane
[@bmorrall]: https://github.com/bmorrall
[@fphilipe]: https://github.com/fphilipe
[@gotrevor]: https://github.com/gotrevor
[@awwaiid]: https://github.com/awwaiid
[@segiddins]: https://github.com/segiddins
[@urbanautomaton]: https://github.com/urbanautomaton.com
[@unmanbearpig]: https://github.com/unmanbearpig
[@maxjacobson]: https://github.com/maxjacobson
[@sliuu]: https://github.com/sliuu
[@edmz]: https://github.com/edmz
[@syndbg]: https://github.com/syndbg
[@wli]: https://github.com/wli
[@caseywebdev]: https://github.com/caseywebdev
[@MGerrior]: https://github.com/MGerrior
[@imtayadeway]: https://github.com/imtayadeway
[@mrfoto]: https://github.com/mrfoto
[@karreiro]: https://github.com/karreiro
[@dreyks]: https://github.com/dreyks
[@hmadison]: https://github.com/hmadison
[@miquella]: https://github.com/miquella
[@jhansche]: https://github.com/jhansche
[@cornelius]: https://github.com/cornelius
[@eagletmt]: https://github.com/eagletmt
[@apiology]: https://github.com/apiology
[@alexdowad]: https://github.com/alexdowad
[@minustehbare]: https://github.com/minustehbare
[@tansaku]: https://github.com/tansaku
[@ptrippett]: https://github.com/ptrippett
[@br3nda]: https://github.com/br3nda
[@jujugrrr]: https://github.com/jujugrrr
[@sometimesfood]: https://github.com/sometimesfood
[@cgriego]: https://github.com/cgriego
[@savef]: https://github.com/savef
[@volmer]: https://github.com/volmer
[@domcleal]: https://github.com/domcleal
[@codebeige]: https://github.com/codebeige
[@weh]: https://github.com/weh
[@bfontaine]: https://github.com/bfontaine
[@jawshooah]: https://github.com/jawshooah
[@DNNX]: https://github.com/DNNX
[@mvidner]: https://github.com/mvidner
[@mattparlane]: https://github.com/mattparlane
[@drenmi]: https://github.com/drenmi
[@stormbreakerbg]: https://github.com/stormbreakerbg
[@owst]: https://github.com/owst
[@seikichi]: https://github.com/seikichi
[@madwort]: https://github.com/madwort
[@annih]: https://github.com/annih
[@mmcguinn]: https://github.com/mmcguinn
[@pocke]: https://github.com/pocke
[@prsimp]: https://github.com/prsimp
[@ptarjan]: https://github.com/ptarjan
[@jweir]: https://github.com/jweir
[@Fryguy]: https://github.com/Fryguy
[@mikegee]: https://github.com/mikegee
[@tbrisker]: https://github.com/tbrisker
[@necojackarc]: https://github.com/necojackarc
[@laurelfan]: https://github.com/laurelfan
[@amuino]: https://github.com/amuino
[@dylanahsmith]: https://github.com/dylanahsmith
[@gerrywastaken]: https://github.com/gerrywastaken
[@bolshakov]: https://github.com/bolshakov
[@jastkand]: https://github.com/jastkand
[@graemeboy]: https://github.com/graemeboy
[@akihiro17]: https://github.com/akihiro17
[@magni-]: https://github.com/magni-
[@NobodysNightmare]: https://github.com/NobodysNightmare
[@gylaz]: https://github.com/gylaz
[@tjwp]: https://github.com/tjwp
[@neodelf]: https://github.com/neodelf
[@josh]: https://github.com/josh
[@natalzia-paperless]: https://github.com/natalzia-paperless
[@jules2689]: https://github.com/jules2689
[@giannileggio]: https://github.com/giannileggio
[@deivid-rodriguez]: https://github.com/deivid-rodriguez
[@pclalv]: https://github.com/pclalv
[@flexoid]: https://github.com/flexoid
[@sgringwe]: https://github.com/sgringwe
[@Tei]: https://github.com/Tei
[@haziqhafizuddin]: https://github.com/haziqhafizuddin
[@dvandersluis]: https://github.com/dvandersluis
[@QuinnHarris]: https://github.com/QuinnHarris
[@sooyang]: https://github.com/sooyang
[@metcalf]: https://github.com/metcalf
[@annaswims]: https://github.com/annaswims
[@soutaro]: https://github.com/soutaro
[@nicklamuro]: https://github.com/nicklamuro
[@mikezter]: https://github.com/mikezter
[@joejuzl]: https://github.com/joejuzl
[@hedgesky]: https://github.com/hedgesky
[@tjwallace]: https://github.com/tjwallace
[@scottohara]: https://github.com/scottohara
[@koic]: https://github.com/koic
[@groddeck]: https://github.com/groddeck
[@b-t-g]: https://github.com/b-t-g
[@coorasse]: https://github.com/coorasse
[@scottmatthewman]: https://github.com/scottmatthewman
[@tcdowney]: https://github.com/tcdowney
[@logicminds]: https://github.com/logicminds
[@abrom]: https://github.com/abrom
[@thegedge]: https://github.com/thegedge
[@jmks]: https://github.com/jmks/
[@connorjacobsen]: https://github.com/connorjacobsen
[@legendetm]: https://github.com/legendetm
rubocop-0.48.1+dfsg.orig/relnotes/v0.45.0.md 0000664 0000000 0000000 00000031537 13070542236 0020235 0 ustar 00root root 0000000 0000000 ## 0.45.0 (2016-10-31)
### New features
* [#3615](https://github.com/bbatsov/rubocop/pull/3615): Add autocorrection for `Lint/EmptyInterpolation`. ([@pocke][])
* Make `PercentLiteralDelimiters` enforce delimiters around `%I()` too. ([@bronson][])
* [#3408](https://github.com/bbatsov/rubocop/issues/3408): Add check for repeated values in case conditionals. ([@swcraig][])
* [#3646](https://github.com/bbatsov/rubocop/pull/3646): Add new `Lint/EmptyWhen` cop. ([@drenmi][])
* [#3246](https://github.com/bbatsov/rubocop/issues/3246): Add list of all cops to the manual (generated automatically from a rake task). ([@sihu][])
* [#3647](https://github.com/bbatsov/rubocop/issues/3647): Add `--force-default-config` option. ([@jawshooah][])
* [#3570](https://github.com/bbatsov/rubocop/issues/3570): Add new `MultilineIfModifier` cop to avoid usage of if/unless-modifiers on multiline statements. ([@tessi][])
* [#3631](https://github.com/bbatsov/rubocop/issues/3631): Add new `Style/SpaceInLambdaLiteral` cop to check for spaces in lambda literals. ([@swcraig][])
* Add new `Lint/EmptyExpression` cop. ([@drenmi][])
### Bug fixes
* [#3553](https://github.com/bbatsov/rubocop/pull/3553): Make `Style/RedundantSelf` cop to not register an offence for `self.()`. ([@iGEL][])
* [#3474](https://github.com/bbatsov/rubocop/issues/3474): Make the `Rails/TimeZone` only analyze functions which have "Time" in the receiver. ([@b-t-g][])
* [#3607](https://github.com/bbatsov/rubocop/pull/3607): Fix `Style/RedundantReturn` cop for empty if body. ([@pocke][])
* [#3291](https://github.com/bbatsov/rubocop/issues/3291): Improve detection of `raw` and `html_safe` methods in `Rails/OutputSafety`. ([@lumeet][])
* Redundant return style now properly handles empty `when` blocks. ([@albus522][])
* [#3622](https://github.com/bbatsov/rubocop/pull/3622): Fix false positive for `Metrics/MethodLength` and `Metrics/BlockLength`. ([@meganemura][])
* [#3625](https://github.com/bbatsov/rubocop/pull/3625): Fix some cops errors when condition is empty brace. ([@pocke][])
* [#3468](https://github.com/bbatsov/rubocop/issues/3468): Fix bug regarding alignment inside `begin`..`end` block in `Style/MultilineMethodCallIndentation`. ([@jonas054][])
* [#3644](https://github.com/bbatsov/rubocop/pull/3644): Fix generation incorrect documentation. ([@pocke][])
* [#3637](https://github.com/bbatsov/rubocop/issues/3637): Fix Style/NonNilCheck crashing for ternary condition. ([@tejasbubane][])
* [#3654](https://github.com/bbatsov/rubocop/pull/3654): Add missing keywords for `Rails/HttpPositionalArguments`. ([@eitoball][])
* [#3652](https://github.com/bbatsov/rubocop/issues/3652): Avoid crash Rails/HttpPositionalArguments for lvar params when auto-correct. ([@pocke][])
* Fix bug in `Style/SafeNavigation` where there is a check for an object in an elsif statement with a method call on that object in the branch. ([@rrosenblum][])
* [#3660](https://github.com/bbatsov/rubocop/pull/3660): Fix false positive for Rails/SafeNavigation when without receiver. ([@pocke][])
* [#3650](https://github.com/bbatsov/rubocop/issues/3650): Fix `Style/VariableNumber` registering an offense for variables with double digit numbers. ([@rrosenblum][])
* [#3494](https://github.com/bbatsov/rubocop/issues/3494): Check `rails` style indentation also inside blocks in `Style/IndentationWidth`. ([@jonas054][])
* [#3676](https://github.com/bbatsov/rubocop/issues/3676): Ignore raw and html_safe invocations when wrapped inside a safe_join. ([@b-t-g][])
### Changes
* [#3601](https://github.com/bbatsov/rubocop/pull/3601): Change default args for `Style/SingleLineBlockParams`. This cop checks that `reduce` and `inject` use the variable names `a` and `e` for block arguments. These defaults are uncommunicative variable names and thus conflict with the ["Uncommunicative Variable Name" check in Reek](https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Variable-Name.md). Default args changed to `acc` and `elem`.([@jessieay][])
* [#3645](https://github.com/bbatsov/rubocop/pull/3645): Fix bug with empty case when nodes in `Style/RedundantReturn`. ([@tiagocasanovapt][])
* [#3263](https://github.com/bbatsov/rubocop/issues/3263): Fix auto-correct of if statements inside of unless else statements in `Style/ConditionalAssignment`. ([@rrosenblum][])
* Bump default Ruby version to 2.1. ([@drenmi][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
[@tejasbubane]: https://github.com/tejasbubane
[@bmorrall]: https://github.com/bmorrall
[@fphilipe]: https://github.com/fphilipe
[@gotrevor]: https://github.com/gotrevor
[@awwaiid]: https://github.com/awwaiid
[@segiddins]: https://github.com/segiddins
[@urbanautomaton]: https://github.com/urbanautomaton.com
[@unmanbearpig]: https://github.com/unmanbearpig
[@maxjacobson]: https://github.com/maxjacobson
[@sliuu]: https://github.com/sliuu
[@edmz]: https://github.com/edmz
[@syndbg]: https://github.com/syndbg
[@wli]: https://github.com/wli
[@caseywebdev]: https://github.com/caseywebdev
[@MGerrior]: https://github.com/MGerrior
[@imtayadeway]: https://github.com/imtayadeway
[@mrfoto]: https://github.com/mrfoto
[@karreiro]: https://github.com/karreiro
[@dreyks]: https://github.com/dreyks
[@hmadison]: https://github.com/hmadison
[@miquella]: https://github.com/miquella
[@jhansche]: https://github.com/jhansche
[@cornelius]: https://github.com/cornelius
[@eagletmt]: https://github.com/eagletmt
[@apiology]: https://github.com/apiology
[@alexdowad]: https://github.com/alexdowad
[@minustehbare]: https://github.com/minustehbare
[@tansaku]: https://github.com/tansaku
[@ptrippett]: https://github.com/ptrippett
[@br3nda]: https://github.com/br3nda
[@jujugrrr]: https://github.com/jujugrrr
[@sometimesfood]: https://github.com/sometimesfood
[@cgriego]: https://github.com/cgriego
[@savef]: https://github.com/savef
[@volmer]: https://github.com/volmer
[@domcleal]: https://github.com/domcleal
[@codebeige]: https://github.com/codebeige
[@weh]: https://github.com/weh
[@bfontaine]: https://github.com/bfontaine
[@jawshooah]: https://github.com/jawshooah
[@DNNX]: https://github.com/DNNX
[@mvidner]: https://github.com/mvidner
[@mattparlane]: https://github.com/mattparlane
[@drenmi]: https://github.com/drenmi
[@stormbreakerbg]: https://github.com/stormbreakerbg
[@owst]: https://github.com/owst
[@seikichi]: https://github.com/seikichi
[@madwort]: https://github.com/madwort
[@annih]: https://github.com/annih
[@mmcguinn]: https://github.com/mmcguinn
[@pocke]: https://github.com/pocke
[@prsimp]: https://github.com/prsimp
[@ptarjan]: https://github.com/ptarjan
[@jweir]: https://github.com/jweir
[@Fryguy]: https://github.com/Fryguy
[@mikegee]: https://github.com/mikegee
[@tbrisker]: https://github.com/tbrisker
[@necojackarc]: https://github.com/necojackarc
[@laurelfan]: https://github.com/laurelfan
[@amuino]: https://github.com/amuino
[@dylanahsmith]: https://github.com/dylanahsmith
[@gerrywastaken]: https://github.com/gerrywastaken
[@bolshakov]: https://github.com/bolshakov
[@jastkand]: https://github.com/jastkand
[@graemeboy]: https://github.com/graemeboy
[@akihiro17]: https://github.com/akihiro17
[@magni-]: https://github.com/magni-
[@NobodysNightmare]: https://github.com/NobodysNightmare
[@gylaz]: https://github.com/gylaz
[@tjwp]: https://github.com/tjwp
[@neodelf]: https://github.com/neodelf
[@josh]: https://github.com/josh
[@natalzia-paperless]: https://github.com/natalzia-paperless
[@jules2689]: https://github.com/jules2689
[@giannileggio]: https://github.com/giannileggio
[@deivid-rodriguez]: https://github.com/deivid-rodriguez
[@pclalv]: https://github.com/pclalv
[@flexoid]: https://github.com/flexoid
[@sgringwe]: https://github.com/sgringwe
[@Tei]: https://github.com/Tei
[@haziqhafizuddin]: https://github.com/haziqhafizuddin
[@dvandersluis]: https://github.com/dvandersluis
[@QuinnHarris]: https://github.com/QuinnHarris
[@sooyang]: https://github.com/sooyang
[@metcalf]: https://github.com/metcalf
[@annaswims]: https://github.com/annaswims
[@soutaro]: https://github.com/soutaro
[@nicklamuro]: https://github.com/nicklamuro
[@mikezter]: https://github.com/mikezter
[@joejuzl]: https://github.com/joejuzl
[@hedgesky]: https://github.com/hedgesky
[@tjwallace]: https://github.com/tjwallace
[@scottohara]: https://github.com/scottohara
[@koic]: https://github.com/koic
[@groddeck]: https://github.com/groddeck
[@b-t-g]: https://github.com/b-t-g
[@coorasse]: https://github.com/coorasse
[@scottmatthewman]: https://github.com/scottmatthewman
[@tcdowney]: https://github.com/tcdowney
[@logicminds]: https://github.com/logicminds
[@abrom]: https://github.com/abrom
[@thegedge]: https://github.com/thegedge
[@jmks]: https://github.com/jmks/
[@connorjacobsen]: https://github.com/connorjacobsen
[@legendetm]: https://github.com/legendetm
[@bronson]: https://github.com/bronson
[@albus522]: https://github.com/albus522
[@sihu]: https://github.com/sihu
[@swcraig]: https://github.com/swcraig
[@jessieay]: https://github.com/jessieay
[@tiagocasanovapt]: https://github.com/tiagocasanovapt
[@iGEL]: https://github.com/iGEL
[@tessi]: https://github.com/tessi
rubocop-0.48.1+dfsg.orig/relnotes/v0.46.0.md 0000664 0000000 0000000 00000027645 13070542236 0020243 0 ustar 00root root 0000000 0000000 ### New features
* [#3600](https://github.com/bbatsov/rubocop/issues/3600): Add new `Bundler/DuplicatedGem` cop. ([@jmks][])
* [#3624](https://github.com/bbatsov/rubocop/pull/3624): Add new configuration option `empty_lines_special` to `Style/EmptyLinesAroundClassBody` and `Style/EmptyLinesAroundModuleBody`. ([@legendetm][])
* Add new `Style/EmptyMethod` cop. ([@drenmi][])
* `Style/EmptyLiteral` will now auto-correct `Hash.new` when it is the first argument being passed to a method. The arguments will be wrapped with parenthesis. ([@rrosenblum][])
* [#3713](https://github.com/bbatsov/rubocop/pull/3713): Respect `DisabledByDefault` in parent configs. ([@aroben][])
* New cop `Rails/EnumUniqueness` checks for duplicate values defined in enum config. ([@olliebennett][])
* New cop `Rails/EnumUniqueness` checks for duplicate values defined in enum config hash. ([@olliebennett][])
* [#3451](https://github.com/bbatsov/rubocop/issues/3451): Add new `require_parentheses_when_complex` style to `Style/TernaryParentheses` cop. ([@swcraig][])
* [#3600](https://github.com/bbatsov/rubocop/issues/3600): Add new `Bundler/OrderedGems` cop. ([@tdeo][])
* [#3479](https://github.com/bbatsov/rubocop/issues/3479): Add new configuration option `IgnoredPatterns` to `Metrics/LineLength`. ([@jonas054][])
### Changes
* The offense range for `Performance/FlatMap` now includes any parameters that are passed to `flatten`. ([@rrosenblum][])
* [#1747](https://github.com/bbatsov/rubocop/issues/1747): Update `Style/SpecialGlobalVars` messages with a reminder to `require 'English'`. ([@ivanovaleksey][])
* Checks `binding.irb` call by `Lint/Debugger` cop. ([@pocke][])
* [#3742](https://github.com/bbatsov/rubocop/pull/3742): Checks `min` and `max` call by `Perfomance/CompareWithBlock` cop. ([@pocke][])
### Bug fixes
* [#3662](https://github.com/bbatsov/rubocop/issues/3662): Fix the auto-correction of `Lint/UnneededSplatExpansion` when the splat expansion is inside of another array. ([@rrosenblum][])
* [#3699](https://github.com/bbatsov/rubocop/issues/3699): Fix false positive in `Style/VariableNumber` on variable names ending with an underscore. ([@bquorning][])
* [#3687](https://github.com/bbatsov/rubocop/issues/3687): Fix the fact that `Style/TernaryParentheses` cop claims to correct uncorrected offenses. ([@Ana06][])
* [#3568](https://github.com/bbatsov/rubocop/issues/3568): Fix `--auto-gen-config` behavior for `Style/VariableNumber`. ([@jonas054][])
* Add `format` as an acceptable keyword argument for `Rails/HttpPositionalArguments`. ([@aesthetikx][])
* [#3598](https://github.com/bbatsov/rubocop/issues/3598): In `Style/NumericPredicate`, don't report `x != 0` or `x.nonzero?` as the expressions have different values. ([@jonas054][])
* [#3690](https://github.com/bbatsov/rubocop/issues/3690): Do not register an offense for multiline braces with content in `Style/SpaceInsideBlockBraces`. ([@rrosenblum][])
* [#3746](https://github.com/bbatsov/rubocop/issues/3746): `Lint/NonLocalExitFromIterator` does not warn about `return` in a block which is passed to `Object#define_singleton_method`. ([@AlexWayfer][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
[@tejasbubane]: https://github.com/tejasbubane
[@bmorrall]: https://github.com/bmorrall
[@fphilipe]: https://github.com/fphilipe
[@gotrevor]: https://github.com/gotrevor
[@awwaiid]: https://github.com/awwaiid
[@segiddins]: https://github.com/segiddins
[@urbanautomaton]: https://github.com/urbanautomaton.com
[@unmanbearpig]: https://github.com/unmanbearpig
[@maxjacobson]: https://github.com/maxjacobson
[@sliuu]: https://github.com/sliuu
[@edmz]: https://github.com/edmz
[@syndbg]: https://github.com/syndbg
[@wli]: https://github.com/wli
[@caseywebdev]: https://github.com/caseywebdev
[@MGerrior]: https://github.com/MGerrior
[@imtayadeway]: https://github.com/imtayadeway
[@mrfoto]: https://github.com/mrfoto
[@karreiro]: https://github.com/karreiro
[@dreyks]: https://github.com/dreyks
[@hmadison]: https://github.com/hmadison
[@miquella]: https://github.com/miquella
[@jhansche]: https://github.com/jhansche
[@cornelius]: https://github.com/cornelius
[@eagletmt]: https://github.com/eagletmt
[@apiology]: https://github.com/apiology
[@alexdowad]: https://github.com/alexdowad
[@minustehbare]: https://github.com/minustehbare
[@tansaku]: https://github.com/tansaku
[@ptrippett]: https://github.com/ptrippett
[@br3nda]: https://github.com/br3nda
[@jujugrrr]: https://github.com/jujugrrr
[@sometimesfood]: https://github.com/sometimesfood
[@cgriego]: https://github.com/cgriego
[@savef]: https://github.com/savef
[@volmer]: https://github.com/volmer
[@domcleal]: https://github.com/domcleal
[@codebeige]: https://github.com/codebeige
[@weh]: https://github.com/weh
[@bfontaine]: https://github.com/bfontaine
[@jawshooah]: https://github.com/jawshooah
[@DNNX]: https://github.com/DNNX
[@mvidner]: https://github.com/mvidner
[@mattparlane]: https://github.com/mattparlane
[@drenmi]: https://github.com/drenmi
[@stormbreakerbg]: https://github.com/stormbreakerbg
[@owst]: https://github.com/owst
[@seikichi]: https://github.com/seikichi
[@madwort]: https://github.com/madwort
[@annih]: https://github.com/annih
[@mmcguinn]: https://github.com/mmcguinn
[@pocke]: https://github.com/pocke
[@prsimp]: https://github.com/prsimp
[@ptarjan]: https://github.com/ptarjan
[@jweir]: https://github.com/jweir
[@Fryguy]: https://github.com/Fryguy
[@mikegee]: https://github.com/mikegee
[@tbrisker]: https://github.com/tbrisker
[@necojackarc]: https://github.com/necojackarc
[@laurelfan]: https://github.com/laurelfan
[@amuino]: https://github.com/amuino
[@dylanahsmith]: https://github.com/dylanahsmith
[@gerrywastaken]: https://github.com/gerrywastaken
[@bolshakov]: https://github.com/bolshakov
[@jastkand]: https://github.com/jastkand
[@graemeboy]: https://github.com/graemeboy
[@akihiro17]: https://github.com/akihiro17
[@magni-]: https://github.com/magni-
[@NobodysNightmare]: https://github.com/NobodysNightmare
[@gylaz]: https://github.com/gylaz
[@tjwp]: https://github.com/tjwp
[@neodelf]: https://github.com/neodelf
[@josh]: https://github.com/josh
[@natalzia-paperless]: https://github.com/natalzia-paperless
[@jules2689]: https://github.com/jules2689
[@giannileggio]: https://github.com/giannileggio
[@deivid-rodriguez]: https://github.com/deivid-rodriguez
[@pclalv]: https://github.com/pclalv
[@flexoid]: https://github.com/flexoid
[@sgringwe]: https://github.com/sgringwe
[@Tei]: https://github.com/Tei
[@haziqhafizuddin]: https://github.com/haziqhafizuddin
[@dvandersluis]: https://github.com/dvandersluis
[@QuinnHarris]: https://github.com/QuinnHarris
[@sooyang]: https://github.com/sooyang
[@metcalf]: https://github.com/metcalf
[@annaswims]: https://github.com/annaswims
[@soutaro]: https://github.com/soutaro
[@nicklamuro]: https://github.com/nicklamuro
[@mikezter]: https://github.com/mikezter
[@joejuzl]: https://github.com/joejuzl
[@hedgesky]: https://github.com/hedgesky
[@tjwallace]: https://github.com/tjwallace
[@scottohara]: https://github.com/scottohara
[@koic]: https://github.com/koic
[@groddeck]: https://github.com/groddeck
[@b-t-g]: https://github.com/b-t-g
[@coorasse]: https://github.com/coorasse
[@scottmatthewman]: https://github.com/scottmatthewman
[@tcdowney]: https://github.com/tcdowney
[@logicminds]: https://github.com/logicminds
[@abrom]: https://github.com/abrom
[@thegedge]: https://github.com/thegedge
[@jmks]: https://github.com/jmks/
[@connorjacobsen]: https://github.com/connorjacobsen
[@legendetm]: https://github.com/legendetm
[@bronson]: https://github.com/bronson
[@albus522]: https://github.com/albus522
[@sihu]: https://github.com/sihu
[@swcraig]: https://github.com/swcraig
[@jessieay]: https://github.com/jessieay
[@tiagocasanovapt]: https://github.com/tiagocasanovapt
[@iGEL]: https://github.com/iGEL
[@tessi]: https://github.com/tessi
[@ivanovaleksey]: https://github.com/ivanovaleksey
[@Ana06]: https://github.com/Ana06
[@aroben]: https://github.com/aroben
[@olliebennett]: https://github.com/olliebennett
[@aesthetikx]: https://github.com/aesthetikx
[@tdeo]: https://github.com/tdeo
[@AlexWayfer]: https://github.com/AlexWayfer
rubocop-0.48.1+dfsg.orig/relnotes/v0.47.0.md 0000664 0000000 0000000 00000037572 13070542236 0020244 0 ustar 00root root 0000000 0000000 ### New features
* [#3822](https://github.com/bbatsov/rubocop/pull/3822): Add `Rails/FilePath` cop. ([@iguchi1124][])
* [#3821](https://github.com/bbatsov/rubocop/pull/3821): Add `Security/YAMLLoad` cop. ([@cyberdelia][])
* [#3816](https://github.com/bbatsov/rubocop/pull/3816): Add `Security/MarshalLoad` cop. ([@cyberdelia][])
* [#3757](https://github.com/bbatsov/rubocop/pull/3757): Add Auto-Correct for `Bundler/OrderedGems` cop. ([@pocke][])
* `Style/FrozenStringLiteralComment` now supports the style `never` that will remove the `frozen_string_literal` comment. ([@rrosenblum][])
* [#3795](https://github.com/bbatsov/rubocop/pull/3795): Add `Lint/MultipleCompare` cop. ([@pocke][])
* [#3772](https://github.com/bbatsov/rubocop/issues/3772): Allow exclusion of certain methods for `Metrics/BlockLength`. ([@NobodysNightmare][])
* [#3804](https://github.com/bbatsov/rubocop/pull/3804): Add new `Lint/SafeNavigationChain` cop. ([@pocke][])
* [#3670](https://github.com/bbatsov/rubocop/pull/3670): Add `CountBlocks` boolean option to `Metrics/BlockNesting`. It allows blocks to be counted towards the nesting limit. ([@georgyangelov][])
* [#2992](https://github.com/bbatsov/rubocop/issues/2992): Add a configuration to `Style/ConditionalAssignment` to toggle offenses for ternary expressions. ([@rrosenblum][])
* [#3824](https://github.com/bbatsov/rubocop/pull/3824): Add new `Perfomance/RegexpMatch` cop. ([@pocke][])
* [#3825](https://github.com/bbatsov/rubocop/pull/3825): Add new `Rails/SkipsModelValidations` cop. ([@rahulcs][])
* [#3737](https://github.com/bbatsov/rubocop/issues/3737): Add new `Style/MethodCallWithArgsParentheses` cop. ([@dominh][])
* Renamed `MethodCallParentheses` to `MethodCallWithoutArgsParentheses`. ([@dominh][])
* [#3854](https://github.com/bbatsov/rubocop/pull/3854): Add new `Rails/ReversibleMigration` cop. ([@sue445][])
* [#3872](https://github.com/bbatsov/rubocop/pull/3872): Detect `String#%` with hash literal. ([@backus][])
* [#2731](https://github.com/bbatsov/rubocop/issues/2731): Allow configuration of method calls that create methods for `Lint/UselessAccessModifier`. ([@pat][])
### Changes
* [#3820](https://github.com/bbatsov/rubocop/pull/3820): Rename `Lint/Eval` to `Security/Eval`. ([@cyberdelia][])
* [#3725](https://github.com/bbatsov/rubocop/issues/3725): Disable `Style/SingleLineBlockParams` by default. ([@tejasbubane][])
* [#3765](https://github.com/bbatsov/rubocop/pull/3765): Add a validation for supported styles other than EnforcedStyle. `AlignWith`, `IndentWhenRelativeTo` and `EnforcedMode` configurations are renamed. ([@pocke][])
* [#3782](https://github.com/bbatsov/rubocop/pull/3782): Add check for `add_reference` method by `Rails/NotNullColumn` cop. ([@pocke][])
* [#3761](https://github.com/bbatsov/rubocop/pull/3761): Update `Style/RedundantFreeze` message from `Freezing immutable objects is pointless.` to `Do not freeze immutable objects, as freezing them has no effect.`. ([@lucasuyezu][])
* [#3753](https://github.com/bbatsov/rubocop/issues/3753): Change error message of `Bundler/OrderedGems` to mention `Alphabetize Gems`. ([@tejasbubane][])
* [#3802](https://github.com/bbatsov/rubocop/pull/3802): Ignore case when checking Gemfile order. ([@breckenedge][])
* Add missing examples in `Lint` cops documentation. ([@enriikke][])
* Make `Style/EmptyMethod` cop aware of class methods. ([@drenmi][])
* [#3871](https://github.com/bbatsov/rubocop/pull/3871): Add check for void `defined?` and `self` by `Lint/Void` cop. ([@pocke][])
### Bug fixes
* [#3751](https://github.com/bbatsov/rubocop/pull/3751): Avoid crash in `Rails/EnumUniqueness` cop. ([@pocke][])
* [#3766](https://github.com/bbatsov/rubocop/pull/3766): Avoid crash in `Style/ConditionalAssignment` cop with masgn. ([@pocke][])
* [#3770](https://github.com/bbatsov/rubocop/pull/3770): `Style/RedundantParentheses` Don't flag raised to a power negative numeric literals, since removing the parentheses would change the meaning of the expressions. ([@amogil][])
* [#3750](https://github.com/bbatsov/rubocop/issues/3750): Register an offense in `Style/ConditionalAssignment` when the assignment spans multiple lines. ([@rrosenblum][])
* [#3775](https://github.com/bbatsov/rubocop/pull/3775): Avoid crash in `Style/HashSyntax` cop with an empty hash. ([@pocke][])
* [#3783](https://github.com/bbatsov/rubocop/pull/3783): Maintain parentheses in `Rails/HttpPositionalArguments` when methods are defined with them. ([@kevindew][])
* [#3786](https://github.com/bbatsov/rubocop/pull/3786): Avoid crash `Style/ConditionalAssignment` cop with mass assign method. ([@pocke][])
* [#3749](https://github.com/bbatsov/rubocop/pull/3749): Detect corner case of `Style/NumericLitterals`. ([@kamaradclimber][])
* [#3788](https://github.com/bbatsov/rubocop/pull/3788): Prevent bad auto-correct in `Style/Next` when block has nested conditionals. ([@drenmi][])
* [#3807](https://github.com/bbatsov/rubocop/pull/3807): Prevent `Style/Documentation` and `Style/DocumentationMethod` from mistaking RuboCop directives for class documentation. ([@drenmi][])
* [#3815](https://github.com/bbatsov/rubocop/pull/3815): Fix false positive in `Style/IdenticalConditionalBranches` cop when branches have same line at leading. ([@pocke][])
* Fix false negative in `Rails/HttpPositionalArguments` where offense would go undetected if one of the request parameter names matched one of the special keyword arguments. ([@deivid-rodriguez][])
* Fix false negative in `Rails/HttpPositionalArguments` where offense would go undetected if the `:format` keyword was used with other non-special keywords. ([@deivid-rodriguez][])
* [#3406](https://github.com/bbatsov/rubocop/issues/3406): Enable cops if Enabled is not explicitly set to false. ([@metcalf][])
* Fix `Lint/FormatParameterMismatch` for splatted last argument. ([@zverok][])
* [#3853](https://github.com/bbatsov/rubocop/pull/3853): Fix false positive in `RedundantParentheses` cop with multiple expression. ([@pocke][])
* [#3870](https://github.com/bbatsov/rubocop/pull/3870): Avoid crash in `Rails/HttpPositionalArguments`. ([@pocke][])
* [#3869](https://github.com/bbatsov/rubocop/pull/3869): Prevent `Lint/FormatParameterMismatch` from breaking when `#%` is passed an empty array. ([@drenmi][])
* [#3879](https://github.com/bbatsov/rubocop/pull/3879): Properly handle Emacs and Vim magic comments for `FrozenStringLiteralComment`. ([@backus][])
* [#3736](https://github.com/bbatsov/rubocop/issues/3736): Fix to remove accumulator return value by auto-correction in `Style/EachWithObject`. ([@pocke][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@cyberdelia]: https://github.com/cyberdelia
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
[@tejasbubane]: https://github.com/tejasbubane
[@bmorrall]: https://github.com/bmorrall
[@fphilipe]: https://github.com/fphilipe
[@gotrevor]: https://github.com/gotrevor
[@awwaiid]: https://github.com/awwaiid
[@segiddins]: https://github.com/segiddins
[@urbanautomaton]: https://github.com/urbanautomaton.com
[@unmanbearpig]: https://github.com/unmanbearpig
[@maxjacobson]: https://github.com/maxjacobson
[@sliuu]: https://github.com/sliuu
[@edmz]: https://github.com/edmz
[@syndbg]: https://github.com/syndbg
[@wli]: https://github.com/wli
[@caseywebdev]: https://github.com/caseywebdev
[@MGerrior]: https://github.com/MGerrior
[@imtayadeway]: https://github.com/imtayadeway
[@mrfoto]: https://github.com/mrfoto
[@karreiro]: https://github.com/karreiro
[@dreyks]: https://github.com/dreyks
[@hmadison]: https://github.com/hmadison
[@miquella]: https://github.com/miquella
[@jhansche]: https://github.com/jhansche
[@cornelius]: https://github.com/cornelius
[@eagletmt]: https://github.com/eagletmt
[@apiology]: https://github.com/apiology
[@alexdowad]: https://github.com/alexdowad
[@minustehbare]: https://github.com/minustehbare
[@tansaku]: https://github.com/tansaku
[@ptrippett]: https://github.com/ptrippett
[@br3nda]: https://github.com/br3nda
[@jujugrrr]: https://github.com/jujugrrr
[@sometimesfood]: https://github.com/sometimesfood
[@cgriego]: https://github.com/cgriego
[@savef]: https://github.com/savef
[@volmer]: https://github.com/volmer
[@domcleal]: https://github.com/domcleal
[@codebeige]: https://github.com/codebeige
[@weh]: https://github.com/weh
[@bfontaine]: https://github.com/bfontaine
[@jawshooah]: https://github.com/jawshooah
[@DNNX]: https://github.com/DNNX
[@mvidner]: https://github.com/mvidner
[@mattparlane]: https://github.com/mattparlane
[@drenmi]: https://github.com/drenmi
[@georgyangelov]: https://github.com/georgyangelov
[@owst]: https://github.com/owst
[@seikichi]: https://github.com/seikichi
[@madwort]: https://github.com/madwort
[@annih]: https://github.com/annih
[@mmcguinn]: https://github.com/mmcguinn
[@pocke]: https://github.com/pocke
[@prsimp]: https://github.com/prsimp
[@ptarjan]: https://github.com/ptarjan
[@jweir]: https://github.com/jweir
[@Fryguy]: https://github.com/Fryguy
[@mikegee]: https://github.com/mikegee
[@tbrisker]: https://github.com/tbrisker
[@necojackarc]: https://github.com/necojackarc
[@laurelfan]: https://github.com/laurelfan
[@amuino]: https://github.com/amuino
[@dylanahsmith]: https://github.com/dylanahsmith
[@gerrywastaken]: https://github.com/gerrywastaken
[@bolshakov]: https://github.com/bolshakov
[@jastkand]: https://github.com/jastkand
[@graemeboy]: https://github.com/graemeboy
[@akihiro17]: https://github.com/akihiro17
[@magni-]: https://github.com/magni-
[@NobodysNightmare]: https://github.com/NobodysNightmare
[@gylaz]: https://github.com/gylaz
[@tjwp]: https://github.com/tjwp
[@neodelf]: https://github.com/neodelf
[@josh]: https://github.com/josh
[@natalzia-paperless]: https://github.com/natalzia-paperless
[@jules2689]: https://github.com/jules2689
[@giannileggio]: https://github.com/giannileggio
[@deivid-rodriguez]: https://github.com/deivid-rodriguez
[@pclalv]: https://github.com/pclalv
[@flexoid]: https://github.com/flexoid
[@sgringwe]: https://github.com/sgringwe
[@Tei]: https://github.com/Tei
[@haziqhafizuddin]: https://github.com/haziqhafizuddin
[@dvandersluis]: https://github.com/dvandersluis
[@QuinnHarris]: https://github.com/QuinnHarris
[@sooyang]: https://github.com/sooyang
[@metcalf]: https://github.com/metcalf
[@annaswims]: https://github.com/annaswims
[@soutaro]: https://github.com/soutaro
[@nicklamuro]: https://github.com/nicklamuro
[@mikezter]: https://github.com/mikezter
[@joejuzl]: https://github.com/joejuzl
[@hedgesky]: https://github.com/hedgesky
[@tjwallace]: https://github.com/tjwallace
[@scottohara]: https://github.com/scottohara
[@koic]: https://github.com/koic
[@groddeck]: https://github.com/groddeck
[@b-t-g]: https://github.com/b-t-g
[@coorasse]: https://github.com/coorasse
[@scottmatthewman]: https://github.com/scottmatthewman
[@tcdowney]: https://github.com/tcdowney
[@logicminds]: https://github.com/logicminds
[@abrom]: https://github.com/abrom
[@thegedge]: https://github.com/thegedge
[@jmks]: https://github.com/jmks/
[@connorjacobsen]: https://github.com/connorjacobsen
[@legendetm]: https://github.com/legendetm
[@bronson]: https://github.com/bronson
[@albus522]: https://github.com/albus522
[@sihu]: https://github.com/sihu
[@kamaradclimber]: https://github.com/kamaradclimber
[@swcraig]: https://github.com/swcraig
[@jessieay]: https://github.com/jessieay
[@tiagocasanovapt]: https://github.com/tiagocasanovapt
[@iGEL]: https://github.com/iGEL
[@tessi]: https://github.com/tessi
[@ivanovaleksey]: https://github.com/ivanovaleksey
[@Ana06]: https://github.com/Ana06
[@aroben]: https://github.com/aroben
[@olliebennett]: https://github.com/olliebennett
[@aesthetikx]: https://github.com/aesthetikx
[@tdeo]: https://github.com/tdeo
[@AlexWayfer]: https://github.com/AlexWayfer
[@amogil]: https://github.com/amogil
[@kevindew]: https://github.com/kevindew
[@lucasuyezu]: https://github.com/lucasuyezu
[@breckenedge]: https://github.com/breckenedge
[@enriikke]: https://github.com/enriikke
[@iguchi1124]: https://github.com/iguchi1124
[@vergenzt]: https://github.com/vergenzt
[@rahulcs]: https://github.com/rahulcs
[@dominh]: https://github.com/dominh
[@sue445]: https://github.com/sue445
[@zverok]: https://github.com/zverok
[@backus]: https://github.com/backus
[@pat]: https://github.com/pat
rubocop-0.48.1+dfsg.orig/relnotes/v0.47.1.md 0000664 0000000 0000000 00000024723 13070542236 0020237 0 ustar 00root root 0000000 0000000 ### Bug fixes
* [#3911](https://github.com/bbatsov/rubocop/issues/3911): Prevent a crash in `Performance/RegexpMatch` cop with module definition. ([@pocke][])
* [#3908](https://github.com/bbatsov/rubocop/issues/3908): Prevent `Style/AlignHash` from breaking on a keyword splat when using enforced `table` style. ([@drenmi][])
* [#3918](https://github.com/bbatsov/rubocop/issues/3918): Prevent `Rails/EnumUniqueness` from breaking on a non-literal hash value. ([@drenmi][])
* [#3914](https://github.com/bbatsov/rubocop/pull/3914): Fix department resolution for third party cops required through configuration. ([@backus][])
* [#3846](https://github.com/bbatsov/rubocop/issues/3846): `NodePattern` works for hyphenated node types. ([@alexdowad][])
* [#3922](https://github.com/bbatsov/rubocop/issues/3922): Prevent `Style/NegatedIf` from breaking on negated ternary. ([@drenmi][])
* [#3915](https://github.com/bbatsov/rubocop/issues/3915): Fix a false positive in `Lint/SafeNavigationChain` cop with `try` method. ([@pocke][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@cyberdelia]: https://github.com/cyberdelia
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
[@tejasbubane]: https://github.com/tejasbubane
[@bmorrall]: https://github.com/bmorrall
[@fphilipe]: https://github.com/fphilipe
[@gotrevor]: https://github.com/gotrevor
[@awwaiid]: https://github.com/awwaiid
[@segiddins]: https://github.com/segiddins
[@urbanautomaton]: https://github.com/urbanautomaton.com
[@unmanbearpig]: https://github.com/unmanbearpig
[@maxjacobson]: https://github.com/maxjacobson
[@sliuu]: https://github.com/sliuu
[@edmz]: https://github.com/edmz
[@syndbg]: https://github.com/syndbg
[@wli]: https://github.com/wli
[@caseywebdev]: https://github.com/caseywebdev
[@MGerrior]: https://github.com/MGerrior
[@imtayadeway]: https://github.com/imtayadeway
[@mrfoto]: https://github.com/mrfoto
[@karreiro]: https://github.com/karreiro
[@dreyks]: https://github.com/dreyks
[@hmadison]: https://github.com/hmadison
[@miquella]: https://github.com/miquella
[@jhansche]: https://github.com/jhansche
[@cornelius]: https://github.com/cornelius
[@eagletmt]: https://github.com/eagletmt
[@apiology]: https://github.com/apiology
[@alexdowad]: https://github.com/alexdowad
[@minustehbare]: https://github.com/minustehbare
[@tansaku]: https://github.com/tansaku
[@ptrippett]: https://github.com/ptrippett
[@br3nda]: https://github.com/br3nda
[@jujugrrr]: https://github.com/jujugrrr
[@sometimesfood]: https://github.com/sometimesfood
[@cgriego]: https://github.com/cgriego
[@savef]: https://github.com/savef
[@volmer]: https://github.com/volmer
[@domcleal]: https://github.com/domcleal
[@codebeige]: https://github.com/codebeige
[@weh]: https://github.com/weh
[@bfontaine]: https://github.com/bfontaine
[@jawshooah]: https://github.com/jawshooah
[@DNNX]: https://github.com/DNNX
[@mvidner]: https://github.com/mvidner
[@mattparlane]: https://github.com/mattparlane
[@drenmi]: https://github.com/drenmi
[@georgyangelov]: https://github.com/georgyangelov
[@owst]: https://github.com/owst
[@seikichi]: https://github.com/seikichi
[@madwort]: https://github.com/madwort
[@annih]: https://github.com/annih
[@mmcguinn]: https://github.com/mmcguinn
[@pocke]: https://github.com/pocke
[@prsimp]: https://github.com/prsimp
[@ptarjan]: https://github.com/ptarjan
[@jweir]: https://github.com/jweir
[@Fryguy]: https://github.com/Fryguy
[@mikegee]: https://github.com/mikegee
[@tbrisker]: https://github.com/tbrisker
[@necojackarc]: https://github.com/necojackarc
[@laurelfan]: https://github.com/laurelfan
[@amuino]: https://github.com/amuino
[@dylanahsmith]: https://github.com/dylanahsmith
[@gerrywastaken]: https://github.com/gerrywastaken
[@bolshakov]: https://github.com/bolshakov
[@jastkand]: https://github.com/jastkand
[@graemeboy]: https://github.com/graemeboy
[@akihiro17]: https://github.com/akihiro17
[@magni-]: https://github.com/magni-
[@NobodysNightmare]: https://github.com/NobodysNightmare
[@gylaz]: https://github.com/gylaz
[@tjwp]: https://github.com/tjwp
[@neodelf]: https://github.com/neodelf
[@josh]: https://github.com/josh
[@natalzia-paperless]: https://github.com/natalzia-paperless
[@jules2689]: https://github.com/jules2689
[@giannileggio]: https://github.com/giannileggio
[@deivid-rodriguez]: https://github.com/deivid-rodriguez
[@pclalv]: https://github.com/pclalv
[@flexoid]: https://github.com/flexoid
[@sgringwe]: https://github.com/sgringwe
[@Tei]: https://github.com/Tei
[@haziqhafizuddin]: https://github.com/haziqhafizuddin
[@dvandersluis]: https://github.com/dvandersluis
[@QuinnHarris]: https://github.com/QuinnHarris
[@sooyang]: https://github.com/sooyang
[@metcalf]: https://github.com/metcalf
[@annaswims]: https://github.com/annaswims
[@soutaro]: https://github.com/soutaro
[@nicklamuro]: https://github.com/nicklamuro
[@mikezter]: https://github.com/mikezter
[@joejuzl]: https://github.com/joejuzl
[@hedgesky]: https://github.com/hedgesky
[@tjwallace]: https://github.com/tjwallace
[@scottohara]: https://github.com/scottohara
[@koic]: https://github.com/koic
[@groddeck]: https://github.com/groddeck
[@b-t-g]: https://github.com/b-t-g
[@coorasse]: https://github.com/coorasse
[@scottmatthewman]: https://github.com/scottmatthewman
[@tcdowney]: https://github.com/tcdowney
[@logicminds]: https://github.com/logicminds
[@abrom]: https://github.com/abrom
[@thegedge]: https://github.com/thegedge
[@jmks]: https://github.com/jmks/
[@connorjacobsen]: https://github.com/connorjacobsen
[@legendetm]: https://github.com/legendetm
[@bronson]: https://github.com/bronson
[@albus522]: https://github.com/albus522
[@sihu]: https://github.com/sihu
[@kamaradclimber]: https://github.com/kamaradclimber
[@swcraig]: https://github.com/swcraig
[@jessieay]: https://github.com/jessieay
[@tiagocasanovapt]: https://github.com/tiagocasanovapt
[@iGEL]: https://github.com/iGEL
[@tessi]: https://github.com/tessi
[@ivanovaleksey]: https://github.com/ivanovaleksey
[@Ana06]: https://github.com/Ana06
[@aroben]: https://github.com/aroben
[@olliebennett]: https://github.com/olliebennett
[@aesthetikx]: https://github.com/aesthetikx
[@tdeo]: https://github.com/tdeo
[@AlexWayfer]: https://github.com/AlexWayfer
[@amogil]: https://github.com/amogil
[@kevindew]: https://github.com/kevindew
[@lucasuyezu]: https://github.com/lucasuyezu
[@breckenedge]: https://github.com/breckenedge
[@enriikke]: https://github.com/enriikke
[@iguchi1124]: https://github.com/iguchi1124
[@vergenzt]: https://github.com/vergenzt
[@rahulcs]: https://github.com/rahulcs
[@dominh]: https://github.com/dominh
[@sue445]: https://github.com/sue445
[@zverok]: https://github.com/zverok
[@backus]: https://github.com/backus
[@pat]: https://github.com/pat
rubocop-0.48.1+dfsg.orig/relnotes/v0.48.0.md 0000664 0000000 0000000 00000046175 13070542236 0020244 0 ustar 00root root 0000000 0000000 ### New features
* [#4107](https://github.com/bbatsov/rubocop/pull/4107): New `TargetRailsVersion` configuration parameter can be used to specify which version of Rails the inspected code is intended to run on. ([@maxbeizer][])
* [#4104](https://github.com/bbatsov/rubocop/pull/4104): Add `prefix` and `postfix` styles to `Style/NegatedIf`. ([@brandonweiss][])
* [#4083](https://github.com/bbatsov/rubocop/pull/4083): Add new configuration `NumberOfEmptyLines` for `Style/EmptyLineBetweenDefs`. ([@dorian][])
* [#4045](https://github.com/bbatsov/rubocop/pull/4045): Add new configuration `Strict` for `Style/NumericLiteral` to make the change to this cop in 0.47.0 configurable. ([@iGEL][])
* [#4005](https://github.com/bbatsov/rubocop/issues/4005): Add new `AllCops/EnabledByDefault` option. ([@betesh][])
* [#3893](https://github.com/bbatsov/rubocop/issues/3893): Add a new configuration, `IncludeActiveSupportAliases`, to `Performance/DoublStartEndWith`. This configuration will check for ActiveSupport's `starts_with?` and `ends_with?`. ([@rrosenblum][])
* [#3889](https://github.com/bbatsov/rubocop/pull/3889): Add new `Style/EmptyLineAfterMagicComment` cop. ([@backus][])
* [#3800](https://github.com/bbatsov/rubocop/issues/3800): Make `Style/EndOfLine` configurable with `lf`, `crlf`, and `native` (default) styles. ([@jonas054][])
* [#3936](https://github.com/bbatsov/rubocop/issues/3936): Add new `Style/MixinGrouping` cop. ([@drenmi][])
* [#4003](https://github.com/bbatsov/rubocop/issues/4003): Add new `Rails/RelativeDateConstant` cop. ([@sinsoku][])
* [#3984](https://github.com/bbatsov/rubocop/pull/3984): Add new `Style/EmptyLinesAroundBeginBody` cop. ([@pocke][])
* [#3995](https://github.com/bbatsov/rubocop/pull/3995): Add new `Style/EmptyLinesAroundExceptionHandlingKeywords` cop. ([@pocke][])
* [#4019](https://github.com/bbatsov/rubocop/pull/4019): Make configurable `Style/MultilineMemoization` cop. ([@pocke][])
* [#4018](https://github.com/bbatsov/rubocop/pull/4018): Add autocorrect `Lint/EmptyEnsure` cop. ([@pocke][])
* [#4028](https://github.com/bbatsov/rubocop/pull/4028): Add new `Style/IndentHeredoc` cop. ([@pocke][])
* [#3931](https://github.com/bbatsov/rubocop/issues/3931): Add new `Lint/AmbiguousBlockAssociation` cop. ([@smakagon][])
* Add new `Style/InverseMethods` cop. ([@rrosenblum][])
* [#4038](https://github.com/bbatsov/rubocop/pull/4038): Allow `default` key in the `Style/PercentLiteralDelimiters` cop config to set all preferred delimiters. ([@kddeisz][])
* Add `IgnoreMacros` option to `Style/MethodCallWithArgsParentheses`. ([@drenmi][])
* [#3937](https://github.com/bbatsov/rubocop/issues/3937): Add new `Rails/ActiveSupportAliases` cop. ([@tdeo][])
* Add new `Rails/Blank` cop. ([@rrosenblum][])
* Add new `Rails/Present` cop. ([@rrosenblum][])
### Changes
* [#4100](https://github.com/bbatsov/rubocop/issues/4100): Rails/SaveBang should flag `update_attributes`. ([@andriymosin][])
* [#4083](https://github.com/bbatsov/rubocop/pull/4083): `Style/EmptyLineBetweenDefs` doesn't allow more than one empty line between method definitions by default (see `NumberOfEmptyLines`). ([@dorian][])
* [#3997](https://github.com/bbatsov/rubocop/pull/3997): Include all ruby files by default and exclude non-ruby files. ([@dorian][])
* [#4012](https://github.com/bbatsov/rubocop/pull/4012): Mark `foo[:bar]` as not complex in `Style/TernaryParentheses` cop with `require_parentheses_when_complex` style. ([@onk][])
* [#3915](https://github.com/bbatsov/rubocop/issues/3915): Make configurable whitelist for `Lint/SafeNavigationChain` cop. ([@pocke][])
* [#3944](https://github.com/bbatsov/rubocop/issues/3944): Allow keyword arguments in `Style/RaiseArgs` cop. ([@mikegee][])
* Add auto-correct to `Performance/DoubleStartEndWith`. ([@rrosenblum][])
* [#3951](https://github.com/bbatsov/rubocop/pull/3951): Make `Rails/Date` cop to register an offence for a string without timezone. ([@sinsoku][])
* [#4020](https://github.com/bbatsov/rubocop/pull/4020): Fixed `new_cop.rake` suggested path. ([@dabroz][])
* [#4055](https://github.com/bbatsov/rubocop/pull/4055): Add parameters count to offense message for `Metrics/ParameterLists` cop. ([@pocke][])
* [#4081](https://github.com/bbatsov/rubocop/pull/4081): Allow `Marshal.load` if argument is a `Marshal.dump` in `Security/MarshalLoad` cop. ([@droptheplot][])
* [#4124](https://github.com/bbatsov/rubocop/issues/4124): Make `Style/SymbolArray` cop to enable by default. ([@pocke][])
* [#3331](https://github.com/bbatsov/rubocop/issues/3331): Change `Style/MultilineMethodCallIndentation` `indented_relative_to_receiver` to indent relative to the reciever and not relative to the caller. ([@jfelchner][])
* [#4137](https://github.com/bbatsov/rubocop/pull/4137): Allow lines to be exempted from `IndentationWidth` by regex. ([@jfelchner][])
### Bug fixes
* [#4007](https://github.com/bbatsov/rubocop/pull/4007): Skip `Rails/SkipsModelValidations` for methods that don't accept arguments. ([@dorian][])
* [#3923](https://github.com/bbatsov/rubocop/issues/3923): Allow asciibetical sorting in `Bundler/OrderedGems`. ([@mikegee][])
* [#3855](https://github.com/bbatsov/rubocop/issues/3855): Make `Lint/NonLocalExitFromIterator` aware of method definitions. ([@drenmi][])
* [#2643](https://github.com/bbatsov/rubocop/issues/2643): Allow uppercase and dashes in `MagicComment`. ([@mikegee][])
* [#3959](https://github.com/bbatsov/rubocop/issues/3959): Don't wrap "percent arrays" with extra brackets when autocorrecting `Style/MutableConstant`. ([@mikegee][])
* [#3978](https://github.com/bbatsov/rubocop/pull/3978): Fix false positive in `Performance/RegexpMatch` with `English` module. ([@pocke][])
* [#3242](https://github.com/bbatsov/rubocop/issues/3242): Ignore `Errno::ENOENT` during cache cleanup from `File.mtime` too. ([@mikegee][])
* [#3958](https://github.com/bbatsov/rubocop/issues/3958): `Style/SpaceInsideHashLiteralBraces` doesn't add and offence when checking an hash where a value is a left brace string (e.g. { k: '{' }). ([@nodo][])
* [#4006](https://github.com/bbatsov/rubocop/issues/4006): Prevent `Style/WhileUntilModifier` from breaking on a multiline modifier. ([@drenmi][])
* [#3345](https://github.com/bbatsov/rubocop/issues/3345): Allow `Style/WordArray`'s `WordRegex` configuration value to be an instance of `String`. ([@mikegee][])
* [#4013](https://github.com/bbatsov/rubocop/pull/4013): Follow redirects for RemoteConfig. ([@buenaventure][])
* [#3917](https://github.com/bbatsov/rubocop/issues/3917): Rails/FilePath Match nodes in a method call only once. ([@unmanbearpig][])
* [#3673](https://github.com/bbatsov/rubocop/issues/3673): Fix regression on `Style/RedundantSelf` when assigning to same local variable. ([@bankair][])
* [#4047](https://github.com/bbatsov/rubocop/issues/4047): Allow `find_zone` and `find_zone!` methods in `Rails/TimeZone`. ([@attilahorvath][])
* [#3457](https://github.com/bbatsov/rubocop/issues/3457): Clear a warning and prevent new warnings. ([@mikegee][])
* [#4066](https://github.com/bbatsov/rubocop/issues/4066): Register an offense in `Lint/ShadowedException` when an exception is shadowed and there is an implicit begin. ([@rrosenblum][])
* [#4001](https://github.com/bbatsov/rubocop/issues/4001): Lint/UnneededDisable of Metrics/LineLength that isn't unneeded. ([@wkurniawan07][])
* [#3960](https://github.com/bbatsov/rubocop/issues/3960): Let `Include`/`Exclude` paths in all files beginning with `.rubocop` be relative to the configuration file's directory and not to the current directory. ([@jonas054][])
* [#4049](https://github.com/bbatsov/rubocop/pull/4049): Bugfix for `Style/EmptyLiteral` cop. ([@ota42y][])
* [#4112](https://github.com/bbatsov/rubocop/pull/4112): Fix false positives about double quotes in `Style/StringLiterals`, `Style/UnneededCapitalW` and `Style/UnneededPercentQ` cops. ([@pocke][])
* [#4109](https://github.com/bbatsov/rubocop/issues/4109): Fix incorrect auto correction in `Style/SelfAssignment` cop. ([@pocke][])
* [#4110](https://github.com/bbatsov/rubocop/issues/4110): Fix incorrect auto correction in `Style/BracesAroundHashParameters` cop. ([@musialik][])
* [#4084](https://github.com/bbatsov/rubocop/issues/4084): Fix incorrect auto correction in `Style/TernaryParentheses` cop. ([@musialik][])
* [#4102](https://github.com/bbatsov/rubocop/issues/4102): Fix `Security/JSONLoad`, `Security/MarshalLoad` and `Security/YAMLLoad` cops patterns not matching ::Const. ([@musialik][])
* [#3580](https://github.com/bbatsov/rubocop/issues/3580): Handle combinations of `# rubocop:disable all` and `# rubocop:disable SomeCop`. ([@jonas054][])
* [#4124](https://github.com/bbatsov/rubocop/issues/4124): Fix auto correction bugs in `Style/SymbolArray` cop. ([@pocke][])
* [#4128](https://github.com/bbatsov/rubocop/issues/4128): Prevent `Style/CaseIndentation` cop from registering offenses on single-line case statements. ([@drenmi][])
* [#4143](https://github.com/bbatsov/rubocop/issues/4143): Prevent `Style/IdenticalConditionalBranches` from registering offenses when a case statement has an empty when. ([@dpostorivo][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@cyberdelia]: https://github.com/cyberdelia
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
[@tejasbubane]: https://github.com/tejasbubane
[@bmorrall]: https://github.com/bmorrall
[@fphilipe]: https://github.com/fphilipe
[@gotrevor]: https://github.com/gotrevor
[@awwaiid]: https://github.com/awwaiid
[@segiddins]: https://github.com/segiddins
[@urbanautomaton]: https://github.com/urbanautomaton.com
[@unmanbearpig]: https://github.com/unmanbearpig
[@maxjacobson]: https://github.com/maxjacobson
[@sliuu]: https://github.com/sliuu
[@edmz]: https://github.com/edmz
[@syndbg]: https://github.com/syndbg
[@wli]: https://github.com/wli
[@caseywebdev]: https://github.com/caseywebdev
[@MGerrior]: https://github.com/MGerrior
[@imtayadeway]: https://github.com/imtayadeway
[@mrfoto]: https://github.com/mrfoto
[@karreiro]: https://github.com/karreiro
[@dreyks]: https://github.com/dreyks
[@hmadison]: https://github.com/hmadison
[@miquella]: https://github.com/miquella
[@jhansche]: https://github.com/jhansche
[@cornelius]: https://github.com/cornelius
[@eagletmt]: https://github.com/eagletmt
[@apiology]: https://github.com/apiology
[@alexdowad]: https://github.com/alexdowad
[@minustehbare]: https://github.com/minustehbare
[@tansaku]: https://github.com/tansaku
[@ptrippett]: https://github.com/ptrippett
[@br3nda]: https://github.com/br3nda
[@jujugrrr]: https://github.com/jujugrrr
[@sometimesfood]: https://github.com/sometimesfood
[@cgriego]: https://github.com/cgriego
[@savef]: https://github.com/savef
[@volmer]: https://github.com/volmer
[@domcleal]: https://github.com/domcleal
[@codebeige]: https://github.com/codebeige
[@weh]: https://github.com/weh
[@bfontaine]: https://github.com/bfontaine
[@jawshooah]: https://github.com/jawshooah
[@DNNX]: https://github.com/DNNX
[@mvidner]: https://github.com/mvidner
[@mattparlane]: https://github.com/mattparlane
[@drenmi]: https://github.com/drenmi
[@georgyangelov]: https://github.com/georgyangelov
[@owst]: https://github.com/owst
[@seikichi]: https://github.com/seikichi
[@madwort]: https://github.com/madwort
[@annih]: https://github.com/annih
[@mmcguinn]: https://github.com/mmcguinn
[@pocke]: https://github.com/pocke
[@prsimp]: https://github.com/prsimp
[@ptarjan]: https://github.com/ptarjan
[@jweir]: https://github.com/jweir
[@Fryguy]: https://github.com/Fryguy
[@mikegee]: https://github.com/mikegee
[@tbrisker]: https://github.com/tbrisker
[@necojackarc]: https://github.com/necojackarc
[@laurelfan]: https://github.com/laurelfan
[@amuino]: https://github.com/amuino
[@dylanahsmith]: https://github.com/dylanahsmith
[@gerrywastaken]: https://github.com/gerrywastaken
[@bolshakov]: https://github.com/bolshakov
[@jastkand]: https://github.com/jastkand
[@graemeboy]: https://github.com/graemeboy
[@akihiro17]: https://github.com/akihiro17
[@magni-]: https://github.com/magni-
[@NobodysNightmare]: https://github.com/NobodysNightmare
[@gylaz]: https://github.com/gylaz
[@tjwp]: https://github.com/tjwp
[@neodelf]: https://github.com/neodelf
[@josh]: https://github.com/josh
[@natalzia-paperless]: https://github.com/natalzia-paperless
[@jules2689]: https://github.com/jules2689
[@giannileggio]: https://github.com/giannileggio
[@deivid-rodriguez]: https://github.com/deivid-rodriguez
[@pclalv]: https://github.com/pclalv
[@flexoid]: https://github.com/flexoid
[@sgringwe]: https://github.com/sgringwe
[@Tei]: https://github.com/Tei
[@haziqhafizuddin]: https://github.com/haziqhafizuddin
[@dvandersluis]: https://github.com/dvandersluis
[@QuinnHarris]: https://github.com/QuinnHarris
[@sooyang]: https://github.com/sooyang
[@metcalf]: https://github.com/metcalf
[@annaswims]: https://github.com/annaswims
[@soutaro]: https://github.com/soutaro
[@nicklamuro]: https://github.com/nicklamuro
[@mikezter]: https://github.com/mikezter
[@joejuzl]: https://github.com/joejuzl
[@hedgesky]: https://github.com/hedgesky
[@tjwallace]: https://github.com/tjwallace
[@scottohara]: https://github.com/scottohara
[@koic]: https://github.com/koic
[@groddeck]: https://github.com/groddeck
[@b-t-g]: https://github.com/b-t-g
[@coorasse]: https://github.com/coorasse
[@scottmatthewman]: https://github.com/scottmatthewman
[@tcdowney]: https://github.com/tcdowney
[@logicminds]: https://github.com/logicminds
[@abrom]: https://github.com/abrom
[@thegedge]: https://github.com/thegedge
[@jmks]: https://github.com/jmks/
[@connorjacobsen]: https://github.com/connorjacobsen
[@legendetm]: https://github.com/legendetm
[@bronson]: https://github.com/bronson
[@albus522]: https://github.com/albus522
[@sihu]: https://github.com/sihu
[@kamaradclimber]: https://github.com/kamaradclimber
[@swcraig]: https://github.com/swcraig
[@jessieay]: https://github.com/jessieay
[@tiagocasanovapt]: https://github.com/tiagocasanovapt
[@iGEL]: https://github.com/iGEL
[@tessi]: https://github.com/tessi
[@ivanovaleksey]: https://github.com/ivanovaleksey
[@Ana06]: https://github.com/Ana06
[@aroben]: https://github.com/aroben
[@olliebennett]: https://github.com/olliebennett
[@aesthetikx]: https://github.com/aesthetikx
[@tdeo]: https://github.com/tdeo
[@AlexWayfer]: https://github.com/AlexWayfer
[@amogil]: https://github.com/amogil
[@kevindew]: https://github.com/kevindew
[@lucasuyezu]: https://github.com/lucasuyezu
[@breckenedge]: https://github.com/breckenedge
[@enriikke]: https://github.com/enriikke
[@iguchi1124]: https://github.com/iguchi1124
[@vergenzt]: https://github.com/vergenzt
[@rahulcs]: https://github.com/rahulcs
[@dominh]: https://github.com/dominh
[@sue445]: https://github.com/sue445
[@zverok]: https://github.com/zverok
[@backus]: https://github.com/backus
[@pat]: https://github.com/pat
[@sinsoku]: https://github.com/sinsoku
[@nodo]: https://github.com/nodo
[@onk]: https://github.com/onk
[@dabroz]: https://github.com/dabroz
[@buenaventure]: https://github.com/buenaventure
[@dorian]: https://github.com/dorian
[@attilahorvath]: https://github.com/attilahorvath
[@droptheplot]: https://github.com/droptheplot
[@wkurniawan07]: https://github.com/wkurniawan07
[@kddeisz]: https://github.com/kddeisz
[@ota42y]: https://github.com/ota42y
[@smakagon]: https://github.com/smakagon
[@musialik]: https://github.com/musialik
[@twe4ked]: https://github.com/twe4ked
[@maxbeizer]: https://github.com/maxbeizer
[@andriymosin]: https://github.com/andriymosin
[@brandonweiss]: https://github.com/brandonweiss
[@betesh]: https://github.com/betesh
[@dpostorivo]: https://github.com/dpostorivo
rubocop-0.48.1+dfsg.orig/relnotes/v0.48.1.md 0000664 0000000 0000000 00000031755 13070542236 0020243 0 ustar 00root root 0000000 0000000 ### Changes
* [#4219](https://github.com/bbatsov/rubocop/issues/4219): Add a link to style guide for `Style/IndentationConsistency` cop. ([@pocke][])
* [#4168](https://github.com/bbatsov/rubocop/issues/4168): Removed `-n` option. ([@sadovnik][])
* [#4039](https://github.com/bbatsov/rubocop/pull/4039): Change `Style/PercentLiteralDelimiters` default configuration to match Style Guide update. ([@drenmi][])
* [#4235](https://github.com/bbatsov/rubocop/pull/4235): Improved copy of offense message in `Lint/AmbiguousBlockAssociation` cop. ([@smakagon][])
### Bug fixes
* [#4171](https://github.com/bbatsov/rubocop/pull/4171): Prevent `Rails/Blank` from breaking when RHS of `or` is a naked falsiness check. ([@drenmi][])
* [#4189](https://github.com/bbatsov/rubocop/pull/4189): Make `Lint/AmbiguousBlockAssociation` aware of lambdas passed as arguments. ([@drenmi][])
* [#4179](https://github.com/bbatsov/rubocop/pull/4179): Prevent `Rails/Blank` from breaking when LHS of `or` is a naked falsiness check. ([@rrosenblum][])
* [#4172](https://github.com/bbatsov/rubocop/pull/4172): Fix false positives in `Style/MixinGrouping` cop. ([@drenmi][])
* [#4185](https://github.com/bbatsov/rubocop/pull/4185): Make `Lint/NestedMethodDefinition` aware of `#*_exec` class of methods. ([@drenmi][])
* [#4197](https://github.com/bbatsov/rubocop/pull/4197): Fix false positive in `Style/RedundantSelf` cop with parallel assignment. ([@drenmi][])
* [#4199](https://github.com/bbatsov/rubocop/issues/4199): Fix incorrect auto correction in `Style/SymbolArray` and `Style/WordArray` cop. ([@pocke][])
* [#4218](https://github.com/bbatsov/rubocop/pull/4218): Make `Lint/NestedMethodDefinition` aware of class shovel scope. ([@drenmi][])
* [#4198](https://github.com/bbatsov/rubocop/pull/4198): Make `Lint/AmbguousBlockAssociation` aware of operator methods. ([@drenmi][])
* [#4152](https://github.com/bbatsov/rubocop/pull/4152): Make `Style/MethodCallWithArgsParentheses` not require parens on setter methods. ([@drenmi][])
* [#4226](https://github.com/bbatsov/rubocop/pull/4226): Show in `--help` output that `--stdin` takes a file name argument. ([@jonas054][])
* [#4217](https://github.com/bbatsov/rubocop/pull/4217): Fix false positive in `Rails/FilePath` cop with non string argument. ([@soutaro][])
* [#4106](https://github.com/bbatsov/rubocop/pull/4106): Make `Style/TernaryParentheses` unsafe autocorrect detector aware of literals and constants. ([@drenmi][])
* [#4228](https://github.com/bbatsov/rubocop/pull/4228): Fix false positive in `Lint/AmbiguousBlockAssociation` cop. ([@smakagon][])
* [#4234](https://github.com/bbatsov/rubocop/pull/4234): Fix false positive in `Rails/RelativeDate` for lambdas and procs. ([@smakagon][])
[@bbatsov]: https://github.com/bbatsov
[@jonas054]: https://github.com/jonas054
[@yujinakayama]: https://github.com/yujinakayama
[@dblock]: https://github.com/dblock
[@nevir]: https://github.com/nevir
[@daviddavis]: https://github.com/daviddavis
[@sds]: https://github.com/sds
[@fancyremarker]: https://github.com/fancyremarker
[@sinisterchipmunk]: https://github.com/sinisterchipmunk
[@vonTronje]: https://github.com/vonTronje
[@agrimm]: https://github.com/agrimm
[@pmenglund]: https://github.com/pmenglund
[@chulkilee]: https://github.com/chulkilee
[@codez]: https://github.com/codez
[@cyberdelia]: https://github.com/cyberdelia
[@emou]: https://github.com/emou
[@skanev]: http://github.com/skanev
[@claco]: http://github.com/claco
[@rifraf]: http://github.com/rifraf
[@scottmatthewman]: https://github.com/scottmatthewman
[@ma2gedev]: http://github.com/ma2gedev
[@jeremyolliver]: https://github.com/jeremyolliver
[@hannestyden]: https://github.com/hannestyden
[@geniou]: https://github.com/geniou
[@jkogara]: https://github.com/jkogara
[@tmorris-fiksu]: https://github.com/tmorris-fiksu
[@mockdeep]: https://github.com/mockdeep
[@hiroponz]: https://github.com/hiroponz
[@tamird]: https://github.com/tamird
[@fshowalter]: https://github.com/fshowalter
[@cschramm]: https://github.com/cschramm
[@bquorning]: https://github.com/bquorning
[@bcobb]: https://github.com/bcobb
[@irrationalfab]: https://github.com/irrationalfab
[@tommeier]: https://github.com/tommeier
[@sfeldon]: https://github.com/sfeldon
[@biinari]: https://github.com/biinari
[@barunio]: https://github.com/barunio
[@molawson]: https://github.com/molawson
[@wndhydrnt]: https://github.com/wndhydrnt
[@ggilder]: https://github.com/ggilder
[@salbertson]: https://github.com/salbertson
[@camilleldn]: https://github.com/camilleldn
[@mcls]: https://github.com/mcls
[@yous]: https://github.com/yous
[@vrthra]: https://github.com/vrthra
[@SkuliOskarsson]: https://github.com/SkuliOskarsson
[@jspanjers]: https://github.com/jspanjers
[@sch1zo]: https://github.com/sch1zo
[@smangelsdorf]: https://github.com/smangelsdorf
[@mvz]: https://github.com/mvz
[@jfelchner]: https://github.com/jfelchner
[@janraasch]: https://github.com/janraasch
[@jcarbo]: https://github.com/jcarbo
[@oneamtu]: https://github.com/oneamtu
[@toy]: https://github.com/toy
[@Koronen]: https://github.com/Koronen
[@blainesch]: https://github.com/blainesch
[@marxarelli]: https://github.com/marxarelli
[@katieschilling]: https://github.com/katieschilling
[@kakutani]: https://github.com/kakutani
[@rrosenblum]: https://github.com/rrosenblum
[@mattjmcnaughton]: https://github.com/mattjmcnaughton
[@huerlisi]: https://github.com/huerlisi
[@volkert]: https://github.com/volkert
[@lumeet]: https://github.com/lumeet
[@mmozuras]: https://github.com/mmozuras
[@d4rk5eed]: https://github.com/d4rk5eed
[@cshaffer]: https://github.com/cshaffer
[@eitoball]: https://github.com/eitoball
[@iainbeeston]: https://github.com/iainbeeston
[@pimterry]: https://github.com/pimterry
[@palkan]: https://github.com/palkan
[@jdoconnor]: https://github.com/jdoconnor
[@meganemura]: https://github.com/meganemura
[@zvkemp]: https://github.com/zvkemp
[@vassilevsky]: https://github.com/vassilevsky
[@gerry3]: https://github.com/gerry3
[@ypresto]: https://github.com/ypresto
[@clowder]: https://github.com/clowder
[@mudge]: https://github.com/mudge
[@mzp]: https://github.com/mzp
[@bankair]: https://github.com/bankair
[@crimsonknave]: https://github.com/crimsonknave
[@renuo]: https://github.com/renuo
[@sdeframond]: https://github.com/sdeframond
[@til]: https://github.com/til
[@carhartl]: https://github.com/carhartl
[@dylandavidson]: https://github.com/dylandavidson
[@tmr08c]: https://github.com/tmr08c
[@hbd225]: https://github.com/hbd225
[@l8nite]: https://github.com/l8nite
[@sumeet]: https://github.com/sumeet
[@ojab]: https://github.com/ojab
[@chastell]: https://github.com/chastell
[@glasnt]: https://github.com/glasnt
[@crazydog115]: https://github.com/crazydog115
[@RGBD]: https://github.com/RGBD
[@panthomakos]: https://github.com/panthomakos
[@matugm]: https://github.com/matugm
[@m1foley]: https://github.com/m1foley
[@tejasbubane]: https://github.com/tejasbubane
[@bmorrall]: https://github.com/bmorrall
[@fphilipe]: https://github.com/fphilipe
[@gotrevor]: https://github.com/gotrevor
[@awwaiid]: https://github.com/awwaiid
[@segiddins]: https://github.com/segiddins
[@urbanautomaton]: https://github.com/urbanautomaton.com
[@unmanbearpig]: https://github.com/unmanbearpig
[@maxjacobson]: https://github.com/maxjacobson
[@sliuu]: https://github.com/sliuu
[@edmz]: https://github.com/edmz
[@syndbg]: https://github.com/syndbg
[@wli]: https://github.com/wli
[@caseywebdev]: https://github.com/caseywebdev
[@MGerrior]: https://github.com/MGerrior
[@imtayadeway]: https://github.com/imtayadeway
[@mrfoto]: https://github.com/mrfoto
[@karreiro]: https://github.com/karreiro
[@dreyks]: https://github.com/dreyks
[@hmadison]: https://github.com/hmadison
[@miquella]: https://github.com/miquella
[@jhansche]: https://github.com/jhansche
[@cornelius]: https://github.com/cornelius
[@eagletmt]: https://github.com/eagletmt
[@apiology]: https://github.com/apiology
[@alexdowad]: https://github.com/alexdowad
[@minustehbare]: https://github.com/minustehbare
[@tansaku]: https://github.com/tansaku
[@ptrippett]: https://github.com/ptrippett
[@br3nda]: https://github.com/br3nda
[@jujugrrr]: https://github.com/jujugrrr
[@sometimesfood]: https://github.com/sometimesfood
[@cgriego]: https://github.com/cgriego
[@savef]: https://github.com/savef
[@volmer]: https://github.com/volmer
[@domcleal]: https://github.com/domcleal
[@codebeige]: https://github.com/codebeige
[@weh]: https://github.com/weh
[@bfontaine]: https://github.com/bfontaine
[@jawshooah]: https://github.com/jawshooah
[@DNNX]: https://github.com/DNNX
[@mvidner]: https://github.com/mvidner
[@mattparlane]: https://github.com/mattparlane
[@drenmi]: https://github.com/drenmi
[@georgyangelov]: https://github.com/georgyangelov
[@owst]: https://github.com/owst
[@seikichi]: https://github.com/seikichi
[@madwort]: https://github.com/madwort
[@annih]: https://github.com/annih
[@mmcguinn]: https://github.com/mmcguinn
[@pocke]: https://github.com/pocke
[@prsimp]: https://github.com/prsimp
[@ptarjan]: https://github.com/ptarjan
[@jweir]: https://github.com/jweir
[@Fryguy]: https://github.com/Fryguy
[@mikegee]: https://github.com/mikegee
[@tbrisker]: https://github.com/tbrisker
[@necojackarc]: https://github.com/necojackarc
[@laurelfan]: https://github.com/laurelfan
[@amuino]: https://github.com/amuino
[@dylanahsmith]: https://github.com/dylanahsmith
[@gerrywastaken]: https://github.com/gerrywastaken
[@bolshakov]: https://github.com/bolshakov
[@jastkand]: https://github.com/jastkand
[@graemeboy]: https://github.com/graemeboy
[@akihiro17]: https://github.com/akihiro17
[@magni-]: https://github.com/magni-
[@NobodysNightmare]: https://github.com/NobodysNightmare
[@gylaz]: https://github.com/gylaz
[@tjwp]: https://github.com/tjwp
[@neodelf]: https://github.com/neodelf
[@josh]: https://github.com/josh
[@natalzia-paperless]: https://github.com/natalzia-paperless
[@jules2689]: https://github.com/jules2689
[@giannileggio]: https://github.com/giannileggio
[@deivid-rodriguez]: https://github.com/deivid-rodriguez
[@pclalv]: https://github.com/pclalv
[@flexoid]: https://github.com/flexoid
[@sgringwe]: https://github.com/sgringwe
[@Tei]: https://github.com/Tei
[@haziqhafizuddin]: https://github.com/haziqhafizuddin
[@dvandersluis]: https://github.com/dvandersluis
[@QuinnHarris]: https://github.com/QuinnHarris
[@sooyang]: https://github.com/sooyang
[@metcalf]: https://github.com/metcalf
[@annaswims]: https://github.com/annaswims
[@soutaro]: https://github.com/soutaro
[@nicklamuro]: https://github.com/nicklamuro
[@mikezter]: https://github.com/mikezter
[@joejuzl]: https://github.com/joejuzl
[@hedgesky]: https://github.com/hedgesky
[@tjwallace]: https://github.com/tjwallace
[@scottohara]: https://github.com/scottohara
[@koic]: https://github.com/koic
[@groddeck]: https://github.com/groddeck
[@b-t-g]: https://github.com/b-t-g
[@coorasse]: https://github.com/coorasse
[@scottmatthewman]: https://github.com/scottmatthewman
[@tcdowney]: https://github.com/tcdowney
[@logicminds]: https://github.com/logicminds
[@abrom]: https://github.com/abrom
[@thegedge]: https://github.com/thegedge
[@jmks]: https://github.com/jmks/
[@connorjacobsen]: https://github.com/connorjacobsen
[@legendetm]: https://github.com/legendetm
[@bronson]: https://github.com/bronson
[@albus522]: https://github.com/albus522
[@sihu]: https://github.com/sihu
[@kamaradclimber]: https://github.com/kamaradclimber
[@swcraig]: https://github.com/swcraig
[@jessieay]: https://github.com/jessieay
[@tiagocasanovapt]: https://github.com/tiagocasanovapt
[@iGEL]: https://github.com/iGEL
[@tessi]: https://github.com/tessi
[@ivanovaleksey]: https://github.com/ivanovaleksey
[@Ana06]: https://github.com/Ana06
[@aroben]: https://github.com/aroben
[@olliebennett]: https://github.com/olliebennett
[@aesthetikx]: https://github.com/aesthetikx
[@tdeo]: https://github.com/tdeo
[@AlexWayfer]: https://github.com/AlexWayfer
[@amogil]: https://github.com/amogil
[@kevindew]: https://github.com/kevindew
[@lucasuyezu]: https://github.com/lucasuyezu
[@breckenedge]: https://github.com/breckenedge
[@enriikke]: https://github.com/enriikke
[@iguchi1124]: https://github.com/iguchi1124
[@vergenzt]: https://github.com/vergenzt
[@rahulcs]: https://github.com/rahulcs
[@dominh]: https://github.com/dominh
[@sue445]: https://github.com/sue445
[@zverok]: https://github.com/zverok
[@backus]: https://github.com/backus
[@pat]: https://github.com/pat
[@sinsoku]: https://github.com/sinsoku
[@nodo]: https://github.com/nodo
[@onk]: https://github.com/onk
[@dabroz]: https://github.com/dabroz
[@buenaventure]: https://github.com/buenaventure
[@dorian]: https://github.com/dorian
[@attilahorvath]: https://github.com/attilahorvath
[@droptheplot]: https://github.com/droptheplot
[@wkurniawan07]: https://github.com/wkurniawan07
[@kddeisz]: https://github.com/kddeisz
[@ota42y]: https://github.com/ota42y
[@smakagon]: https://github.com/smakagon
[@musialik]: https://github.com/musialik
[@twe4ked]: https://github.com/twe4ked
[@maxbeizer]: https://github.com/maxbeizer
[@andriymosin]: https://github.com/andriymosin
[@brandonweiss]: https://github.com/brandonweiss
[@betesh]: https://github.com/betesh
[@dpostorivo]: https://github.com/dpostorivo
[@konto-andrzeja]: https://github.com/konto-andrzeja
[@sadovnik]: https://github.com/sadovnik
rubocop-0.48.1+dfsg.orig/rubocop.gemspec 0000664 0000000 0000000 00000002407 13070542236 0020156 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
require 'rubocop/version'
require 'English'
Gem::Specification.new do |s|
s.name = 'rubocop'
s.version = RuboCop::Version::STRING
s.platform = Gem::Platform::RUBY
s.required_ruby_version = '>= 2.0.0'
s.authors = ['Bozhidar Batsov', 'Jonas Arvidsson', 'Yuji Nakayama']
s.description = <<-EOF
Automatic Ruby code style checking tool.
Aims to enforce the community-driven Ruby Style Guide.
EOF
s.email = 'rubocop@googlegroups.com'
s.files = `git ls-files assets bin config lib LICENSE.txt README.md \
spec/support/cop_helper.rb`
.split($RS)
s.executables = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
s.extra_rdoc_files = ['LICENSE.txt', 'README.md']
s.homepage = 'http://github.com/bbatsov/rubocop'
s.licenses = ['MIT']
s.summary = 'Automatic Ruby code style checking tool.'
s.add_runtime_dependency('rainbow', '>= 1.99.1', '< 3.0')
s.add_runtime_dependency('parser', '>= 2.3.3.1', '< 3.0')
s.add_runtime_dependency('powerpack', '~> 0.1')
s.add_runtime_dependency('ruby-progressbar', '~> 1.7')
s.add_runtime_dependency('unicode-display_width', '~> 1.0', '>= 1.0.1')
s.add_development_dependency('bundler', '~> 1.3')
end
rubocop-0.48.1+dfsg.orig/spec/ 0000775 0000000 0000000 00000000000 13070542236 0016067 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/spec/fixtures/ 0000775 0000000 0000000 00000000000 13070542236 0017740 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/spec/fixtures/html_formatter/ 0000775 0000000 0000000 00000000000 13070542236 0022767 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/spec/fixtures/html_formatter/expected.html 0000664 0000000 0000000 00000057306 13070542236 0025471 0 ustar 00root root 0000000 0000000
RuboCop Inspection Report
app/controllers/application_controller.rb - 2 offenses
Line #1 –
convention:
Missing top-level class documentation comment.
class ApplicationController < ActionController::Base
Line #6 –
convention:
Use only ascii symbols in comments.
# “Test encoding issues by using curly quotes”
app/controllers/books_controller.rb - 11 offenses
Line #1 –
convention:
Missing top-level class documentation comment.
class BooksController < ApplicationController
Line #2 –
convention:
Use %i or %I for an array of symbols.
before_action :set_book, only: [:show, :edit, :update, :destroy]
Line #12 –
convention:
Put empty method definitions on a single line.
def show
Line #21 –
convention:
Put empty method definitions on a single line.
def edit
Line #31 –
convention:
Line is too long. [83/80]
format.html { redirect_to @book, notice: 'Book was successfully created.' }
Line #45 –
convention:
Line is too long. [83/80]
format.html { redirect_to @book, notice: 'Book was successfully updated.' }
Line #59 –
convention:
Line is too long. [87/80]
format.html { redirect_to books_url, notice: 'Book was successfully destroyed.' }
Line #64 –
convention:
Keep a blank line before and after private.
private
Line #66 –
convention:
Inconsistent indentation detected.
def set_book
Line #70 –
convention:
Line is too long. [88/80]
# Never trust parameters from the scary internet, only allow the white list through.
Line #71 –
convention:
Inconsistent indentation detected.
def book_params
app/models/book.rb - 6 offenses
Line #1 –
convention:
Missing top-level class documentation comment.
class Book < ActiveRecord::Base
Line #2 –
convention:
Use snake_case for method names.
def someMethod
Line #3 –
warning:
Useless assignment to variable - foo.
foo = bar = baz
Line #3 –
warning:
Useless assignment to variable - bar.
foo = bar = baz
Line #4 –
convention:
Avoid using rescue in its modifier form.
Regexp.new(/\A<p>(.*)<\/p>\Z/m).match(full_document)[1] rescue full_document
Line #4 –
convention:
Use %r around regular expression.
Regexp.new(/\A<p>(.*)<\/p>\Z/m).match(full_document)[1] rescue full_document
rubocop-0.48.1+dfsg.orig/spec/fixtures/html_formatter/project/ 0000775 0000000 0000000 00000000000 13070542236 0024435 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/spec/fixtures/html_formatter/project/app/ 0000775 0000000 0000000 00000000000 13070542236 0025215 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/spec/fixtures/html_formatter/project/app/controllers/ 0000775 0000000 0000000 00000000000 13070542236 0027563 5 ustar 00root root 0000000 0000000 application_controller.rb 0000664 0000000 0000000 00000000402 13070542236 0034573 0 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/spec/fixtures/html_formatter/project/app/controllers class ApplicationController < ActionController::Base
# Prevent CSRF attacks by raising an exception.
# For APIs, you may want to use :null_session instead.
protect_from_forgery with: :exception
# “Test encoding issues by using curly quotes”
end
rubocop-0.48.1+dfsg.orig/spec/fixtures/html_formatter/project/app/controllers/books_controller.rb 0000664 0000000 0000000 00000003354 13070542236 0033475 0 ustar 00root root 0000000 0000000 class BooksController < ApplicationController
before_action :set_book, only: [:show, :edit, :update, :destroy]
# GET /books
# GET /books.json
def index
@books = Book.all
end
# GET /books/1
# GET /books/1.json
def show
end
# GET /books/new
def new
@book = Book.new
end
# GET /books/1/edit
def edit
end
# POST /books
# POST /books.json
def create
@book = Book.new(book_params)
respond_to do |format|
if @book.save
format.html { redirect_to @book, notice: 'Book was successfully created.' }
format.json { render :show, status: :created, location: @book }
else
format.html { render :new }
format.json { render json: @book.errors, status: :unprocessable_entity }
end
end
end
# PATCH/PUT /books/1
# PATCH/PUT /books/1.json
def update
respond_to do |format|
if @book.update(book_params)
format.html { redirect_to @book, notice: 'Book was successfully updated.' }
format.json { render :show, status: :ok, location: @book }
else
format.html { render :edit }
format.json { render json: @book.errors, status: :unprocessable_entity }
end
end
end
# DELETE /books/1
# DELETE /books/1.json
def destroy
@book.destroy
respond_to do |format|
format.html { redirect_to books_url, notice: 'Book was successfully destroyed.' }
format.json { head :no_content }
end
end
private
# Use callbacks to share common setup or constraints between actions.
def set_book
@book = Book.find(params[:id])
end
# Never trust parameters from the scary internet, only allow the white list through.
def book_params
params.require(:book).permit(:name)
end
end
rubocop-0.48.1+dfsg.orig/spec/fixtures/html_formatter/project/app/models/ 0000775 0000000 0000000 00000000000 13070542236 0026500 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/spec/fixtures/html_formatter/project/app/models/book.rb 0000664 0000000 0000000 00000000240 13070542236 0027753 0 ustar 00root root 0000000 0000000 class Book < ActiveRecord::Base
def someMethod
foo = bar = baz
Regexp.new(/\A(.*)<\/p>\Z/m).match(full_document)[1] rescue full_document
end
end
rubocop-0.48.1+dfsg.orig/spec/isolated_environment_spec.rb 0000664 0000000 0000000 00000001412 13070542236 0023654 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe 'isolated environment', :isolated_environment do
include_context 'cli spec behavior'
let(:cli) { RuboCop::CLI.new }
# Configuration files above the work directory shall not disturb the
# tests. This is especially important on Windows where the temporary
# directory is under the user's home directory. On any platform we don't want
# a .rubocop.yml file in the temporary directory to affect the outcome of
# rspec.
it 'is not affected by a config file above the work directory' do
create_file('../.rubocop.yml', ['inherit_from: missing_file.yml'])
create_file('ex.rb', ['# encoding: utf-8'])
# A return value of 0 means that the erroneous config file was not read.
expect(cli.run([])).to eq(0)
end
end
rubocop-0.48.1+dfsg.orig/spec/project_spec.rb 0000664 0000000 0000000 00000012321 13070542236 0021073 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe 'RuboCop Project' do
let(:cop_names) { RuboCop::Cop::Cop.all.map(&:cop_name) }
shared_context 'configuration file' do |config_path|
subject(:config) { RuboCop::ConfigLoader.load_file(config_path) }
let(:configuration_keys) { config.keys }
let(:raw_configuration) { config.to_h.values }
end
describe 'default configuration file' do
include_context 'configuration file', 'config/default.yml'
it 'has configuration for all cops' do
expect(configuration_keys).to match_array(%w[AllCops Rails] + cop_names)
end
it 'has a nicely formatted description for all cops' do
cop_names.each do |name|
description = config[name]['Description']
expect(description).not_to be_nil
expect(description).not_to include("\n")
end
end
it 'has a SupportedStyles for all EnforcedStyle' \
'and EnforcedStyle is valid' do
errors = []
cop_names.each do |name|
enforced_styles = config[name]
.select { |key, _| key.start_with?('Enforced') }
enforced_styles.each do |style_name, _style|
supported_key = RuboCop::Cop::Util.to_supported_styles(style_name)
valid = config[name][supported_key]
errors.push("#{supported_key} is missing for #{name}") unless valid
end
end
raise errors.join("\n") unless errors.empty?
end
end
describe 'cop message' do
let(:cops) { RuboCop::Cop::Cop.all }
it 'end with a period or a question mark' do
cops.each do |cop|
begin
msg = cop.const_get(:MSG)
rescue NameError
next
end
expect(msg).to match(/(?:[.?]|(?:\[.+\])|%s)$/)
end
end
end
describe 'config/disabled.yml' do
include_context 'configuration file', 'config/disabled.yml'
it 'disables all cops in the file' do
expect(raw_configuration)
.to all(match(hash_including('Enabled' => false)))
end
end
describe 'config/enabled.yml' do
include_context 'configuration file', 'config/enabled.yml'
it 'enables all cops in the file' do
expect(raw_configuration)
.to all(match(hash_including('Enabled' => true)))
end
end
describe 'changelog' do
subject(:changelog) do
path = File.join(File.dirname(__FILE__), '..', 'CHANGELOG.md')
File.read(path)
end
it 'has link definitions for all implicit links' do
implicit_link_names = changelog.scan(/\[([^\]]+)\]\[\]/).flatten.uniq
implicit_link_names.each do |name|
expect(changelog).to include("[#{name}]: http")
end
end
describe 'entry' do
subject(:entries) { lines.grep(/^\*/).map(&:chomp) }
let(:lines) { changelog.each_line }
it 'has a whitespace between the * and the body' do
entries.each do |entry|
expect(entry).to match(/^\* \S/)
end
end
context 'after version 0.14.0' do
let(:lines) do
changelog.each_line.take_while do |line|
!line.start_with?('## 0.14.0')
end
end
it 'has a link to the contributors at the end' do
entries.each do |entry|
expect(entry).to match(/\(\[@\S+\]\[\](?:, \[@\S+\]\[\])*\)$/)
end
end
end
describe 'link to related issue' do
let(:issues) do
entries.map do |entry|
entry.match(/\[(?[#\d]+)\]\((?[^\)]+)\)/)
end.compact
end
it 'has an issue number prefixed with #' do
issues.each do |issue|
expect(issue[:number]).to match(/^#\d+$/)
end
end
it 'has a valid URL' do
issues.each do |issue|
number = issue[:number].gsub(/\D/, '')
pattern = %r{^https://github\.com/bbatsov/rubocop/(?:issues|pull)/#{number}$} # rubocop:disable Metrics/LineLength
expect(issue[:url]).to match(pattern)
end
end
it 'has a colon and a whitespace at the end' do
entries_including_issue_link = entries.select do |entry|
entry.match(/^\*\s*\[/)
end
entries_including_issue_link.each do |entry|
expect(entry).to include('): ')
end
end
end
describe 'body' do
let(:bodies) do
entries.map do |entry|
entry
.gsub(/`[^`]+`/, '``')
.sub(/^\*\s*(?:\[.+?\):\s*)?/, '')
.sub(/\s*\([^\)]+\)$/, '')
end
end
it 'does not start with a lower case' do
bodies.each do |body|
expect(body).not_to match(/^[a-z]/)
end
end
it 'ends with a punctuation' do
bodies.each do |body|
expect(body).to match(/[\.\!]$/)
end
end
end
end
end
describe 'requiring all of `lib` with verbose warnings enabled' do
it 'emits no warnings' do
whitelisted = ->(line) { line =~ /warning: private attribute\?$/ }
warnings = `ruby -Ilib -w -W2 lib/rubocop.rb 2>&1`
.lines
.grep(%r{/lib/rubocop}) # ignore warnings from dependencies
.reject(&whitelisted)
expect(warnings).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/ 0000775 0000000 0000000 00000000000 13070542236 0017540 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/spec/rubocop/ast/ 0000775 0000000 0000000 00000000000 13070542236 0020327 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/spec/rubocop/ast/and_node_spec.rb 0000664 0000000 0000000 00000005631 13070542236 0023442 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::AST::AndNode do
let(:and_node) { parse_source(source).ast }
describe '.new' do
context 'with a logical and node' do
let(:source) do
':foo && :bar'
end
it { expect(and_node).to be_a(described_class) }
end
context 'with a semantic and node' do
let(:source) do
':foo and :bar'
end
it { expect(and_node).to be_a(described_class) }
end
end
describe '#logical_operator?' do
context 'with a logical and node' do
let(:source) do
':foo && :bar'
end
it { expect(and_node).to be_logical_operator }
end
context 'with a semantic and node' do
let(:source) do
':foo and :bar'
end
it { expect(and_node).not_to be_logical_operator }
end
end
describe '#semantic_operator?' do
context 'with a logical and node' do
let(:source) do
':foo && :bar'
end
it { expect(and_node).not_to be_semantic_operator }
end
context 'with a semantic and node' do
let(:source) do
':foo and :bar'
end
it { expect(and_node).to be_semantic_operator }
end
end
describe '#operator' do
context 'with a logical and node' do
let(:source) do
':foo && :bar'
end
it { expect(and_node.operator).to eq('&&') }
end
context 'with a semantic and node' do
let(:source) do
':foo and :bar'
end
it { expect(and_node.operator).to eq('and') }
end
end
describe '#alternate_operator' do
context 'with a logical and node' do
let(:source) do
':foo && :bar'
end
it { expect(and_node.alternate_operator).to eq('and') }
end
context 'with a semantic and node' do
let(:source) do
':foo and :bar'
end
it { expect(and_node.alternate_operator).to eq('&&') }
end
end
describe '#inverse_operator' do
context 'with a logical and node' do
let(:source) do
':foo && :bar'
end
it { expect(and_node.inverse_operator).to eq('||') }
end
context 'with a semantic and node' do
let(:source) do
':foo and :bar'
end
it { expect(and_node.inverse_operator).to eq('or') }
end
end
describe '#lhs' do
context 'with a logical and node' do
let(:source) do
':foo && 42'
end
it { expect(and_node.lhs).to be_sym_type }
end
context 'with a semantic and node' do
let(:source) do
':foo and 42'
end
it { expect(and_node.lhs).to be_sym_type }
end
end
describe '#rhs' do
context 'with a logical and node' do
let(:source) do
':foo && 42'
end
it { expect(and_node.rhs).to be_int_type }
end
context 'with a semantic and node' do
let(:source) do
':foo and 42'
end
it { expect(and_node.rhs).to be_int_type }
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/ast/array_node_spec.rb 0000664 0000000 0000000 00000003774 13070542236 0024024 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::AST::ArrayNode do
let(:array_node) { parse_source(source).ast }
describe '.new' do
let(:source) { '[]' }
it { expect(array_node).to be_a(described_class) }
end
describe '#values' do
context 'with an empty array' do
let(:source) { '[]' }
it { expect(array_node.values).to be_empty }
end
context 'with an array of literals' do
let(:source) { '[1, 2, 3]' }
it { expect(array_node.values.size).to eq(3) }
it { expect(array_node.values).to all(be_literal) }
end
context 'with an array of variables' do
let(:source) { '[foo, bar]' }
it { expect(array_node.values.size).to eq(2) }
it { expect(array_node.values).to all(be_send_type) }
end
end
describe '#square_brackets?' do
context 'with square brackets' do
let(:source) { '[1, 2, 3]' }
it { expect(array_node.square_brackets?).to be_truthy }
end
context 'with a percent literal' do
let(:source) { '%w(foo bar)' }
it { expect(array_node.square_brackets?).to be_falsey }
end
end
describe '#percent_literal?' do
context 'with square brackets' do
let(:source) { '[1, 2, 3]' }
it { expect(array_node.percent_literal?).to be_falsey }
it { expect(array_node.percent_literal?(:string)).to be_falsey }
it { expect(array_node.percent_literal?(:symbol)).to be_falsey }
end
context 'with a string percent literal' do
let(:source) { '%w(foo bar)' }
it { expect(array_node.percent_literal?).to be_truthy }
it { expect(array_node.percent_literal?(:string)).to be_truthy }
it { expect(array_node.percent_literal?(:symbol)).to be_falsey }
end
context 'with a symbol percent literal' do
let(:source) { '%i(foo bar)' }
it { expect(array_node.percent_literal?).to be_truthy }
it { expect(array_node.percent_literal?(:string)).to be_falsey }
it { expect(array_node.percent_literal?(:symbol)).to be_truthy }
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/ast/case_node_spec.rb 0000664 0000000 0000000 00000004407 13070542236 0023613 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::AST::CaseNode do
let(:case_node) { parse_source(source).ast }
describe '.new' do
let(:source) do
['case',
'when :foo then bar',
'end'].join("\n")
end
it { expect(case_node).to be_a(described_class) }
end
describe '#keyword' do
let(:source) do
['case',
'when :foo then bar',
'end'].join("\n")
end
it { expect(case_node.keyword).to eq('case') }
end
describe '#when_branches' do
let(:source) do
['case',
'when :foo then 1',
'when :bar then 2',
'when :baz then 3',
'end'].join("\n")
end
it { expect(case_node.when_branches.size).to eq(3) }
it { expect(case_node.when_branches).to all(be_when_type) }
end
describe '#each_when' do
let(:source) do
['case',
'when :foo then 1',
'when :bar then 2',
'when :baz then 3',
'end'].join("\n")
end
context 'when not passed a block' do
it { expect(case_node.each_when).to be_an(Enumerator) }
end
context 'when passed a block' do
it 'yields all the conditions' do
expect { |b| case_node.each_when(&b) }
.to yield_successive_args(*case_node.when_branches)
end
end
end
describe '#else?' do
context 'without an else statement' do
let(:source) do
['case',
'when :foo then :bar',
'end'].join("\n")
end
it { expect(case_node.else?).to be_falsey }
end
context 'with an else statement' do
let(:source) do
['case',
'when :foo then :bar',
'else :baz',
'end'].join("\n")
end
it { expect(case_node.else?).to be_truthy }
end
end
describe '#else_branch' do
describe '#else?' do
context 'without an else statement' do
let(:source) do
['case',
'when :foo then :bar',
'end'].join("\n")
end
it { expect(case_node.else_branch).to be_nil }
end
context 'with an else statement' do
let(:source) do
['case',
'when :foo then :bar',
'else :baz',
'end'].join("\n")
end
it { expect(case_node.else_branch).to be_sym_type }
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/ast/ensure_node_spec.rb 0000664 0000000 0000000 00000000661 13070542236 0024177 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::AST::EnsureNode do
let(:ensure_node) { parse_source(source).ast.children.first }
describe '.new' do
let(:source) { 'begin; beginbody; ensure; ensurebody; end' }
it { expect(ensure_node).to be_a(described_class) }
end
describe '#body' do
let(:source) { 'begin; beginbody; ensure; :ensurebody; end' }
it { expect(ensure_node.body).to be_sym_type }
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/ast/for_node_spec.rb 0000664 0000000 0000000 00000002110 13070542236 0023453 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::AST::ForNode do
let(:for_node) { parse_source(source).ast }
describe '.new' do
let(:source) { 'for foo in bar; baz; end' }
it { expect(for_node).to be_a(described_class) }
end
describe '#keyword' do
let(:source) { 'for foo in bar; baz; end' }
it { expect(for_node.keyword).to eq('for') }
end
describe '#do?' do
context 'with a do keyword' do
let(:source) { 'for foo in bar do baz; end' }
it { expect(for_node.do?).to be_truthy }
end
context 'without a do keyword' do
let(:source) { 'for foo in bar; baz; end' }
it { expect(for_node.do?).to be_falsey }
end
end
describe '#variable' do
let(:source) { 'for foo in :bar; :baz; end' }
it { expect(for_node.variable).to be_lvasgn_type }
end
describe '#collection' do
let(:source) { 'for foo in :bar; baz; end' }
it { expect(for_node.collection).to be_sym_type }
end
describe '#body' do
let(:source) { 'for foo in bar; :baz; end' }
it { expect(for_node.body).to be_sym_type }
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/ast/hash_node_spec.rb 0000664 0000000 0000000 00000013201 13070542236 0023613 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::AST::HashNode do
let(:hash_node) { parse_source(source).ast }
describe '.new' do
let(:source) { '{}' }
it { expect(hash_node).to be_a(described_class) }
end
describe '#pairs' do
context 'with an empty hash' do
let(:source) { '{}' }
it { expect(hash_node.pairs).to be_empty }
end
context 'with a hash of literals' do
let(:source) { '{ a: 1, b: 2, c: 3 }' }
it { expect(hash_node.pairs.size).to eq(3) }
it { expect(hash_node.pairs).to all(be_pair_type) }
end
context 'with a hash of variables' do
let(:source) { '{ a: foo, b: bar }' }
it { expect(hash_node.pairs.size).to eq(2) }
it { expect(hash_node.pairs).to all(be_pair_type) }
end
end
describe '#empty?' do
context 'with an empty hash' do
let(:source) { '{}' }
it { expect(hash_node).to be_empty }
end
context 'with a hash containing pairs' do
let(:source) { '{ a: 1, b: 2 }' }
it { expect(hash_node).to_not be_empty }
end
context 'with a hash containing a keyword splat' do
let(:source) { '{ **foo }' }
it { expect(hash_node).to_not be_empty }
end
end
describe '#keys' do
context 'with an empty hash' do
let(:source) { '{}' }
it { expect(hash_node.keys).to be_empty }
end
context 'with a hash with symbol keys' do
let(:source) { '{ a: 1, b: 2, c: 3 }' }
it { expect(hash_node.keys.size).to eq(3) }
it { expect(hash_node.keys).to all(be_sym_type) }
end
context 'with a hash with string keys' do
let(:source) { "{ 'a' => foo,'b' => bar }" }
it { expect(hash_node.keys.size).to eq(2) }
it { expect(hash_node.keys).to all(be_str_type) }
end
end
describe '#each_key' do
let(:source) { '{ a: 1, b: 2, c: 3 }' }
context 'when not passed a block' do
it { expect(hash_node.each_key).to be_an(Enumerator) }
end
context 'when passed a block' do
let(:expected) do
[
hash_node.pairs[0].key,
hash_node.pairs[1].key,
hash_node.pairs[2].key
]
end
it 'yields all the pairs' do
expect { |b| hash_node.each_key(&b) }
.to yield_successive_args(*expected)
end
end
end
describe '#values' do
context 'with an empty hash' do
let(:source) { '{}' }
it { expect(hash_node.values).to be_empty }
end
context 'with a hash with literal values' do
let(:source) { '{ a: 1, b: 2, c: 3 }' }
it { expect(hash_node.values.size).to eq(3) }
it { expect(hash_node.values).to all(be_literal) }
end
context 'with a hash with string keys' do
let(:source) { '{ a: foo, b: bar }' }
it { expect(hash_node.values.size).to eq(2) }
it { expect(hash_node.values).to all(be_send_type) }
end
end
describe '#each_value' do
let(:source) { '{ a: 1, b: 2, c: 3 }' }
context 'when not passed a block' do
it { expect(hash_node.each_value).to be_an(Enumerator) }
end
context 'when passed a block' do
let(:expected) do
[
hash_node.pairs[0].value,
hash_node.pairs[1].value,
hash_node.pairs[2].value
]
end
it 'yields all the pairs' do
expect { |b| hash_node.each_value(&b) }
.to yield_successive_args(*expected)
end
end
end
describe '#each_pair' do
let(:source) { '{ a: 1, b: 2, c: 3 }' }
context 'when not passed a block' do
it { expect(hash_node.each_pair).to be_an(Enumerator) }
end
context 'when passed a block' do
let(:expected) do
[
[*hash_node.pairs[0]],
[*hash_node.pairs[1]],
[*hash_node.pairs[2]]
]
end
it 'yields all the pairs' do
expect { |b| hash_node.each_pair(&b) }
.to yield_successive_args(*expected)
end
end
end
describe '#pairs_on_same_line?' do
context 'with all pairs on the same line' do
let(:source) { '{ a: 1, b: 2 }' }
it { expect(hash_node.pairs_on_same_line?).to be_truthy }
end
context 'with no pairs on the same line' do
let(:source) do
['{ a: 1,',
' b: 2 }'].join("\n")
end
it { expect(hash_node.pairs_on_same_line?).to be_falsey }
end
context 'with some pairs on the same line' do
let(:source) do
['{ a: 1,',
' b: 2, c: 3 }'].join("\n")
end
it { expect(hash_node.pairs_on_same_line?).to be_truthy }
end
end
describe '#mixed_delimiters?' do
context 'when all pairs are using a colon delimiter' do
let(:source) { '{ a: 1, b: 2 }' }
it { expect(hash_node.mixed_delimiters?).to be_falsey }
end
context 'when all pairs are using a hash rocket delimiter' do
let(:source) { '{ :a => 1, :b => 2 }' }
it { expect(hash_node.mixed_delimiters?).to be_falsey }
end
context 'when pairs are using different delimiters' do
let(:source) { '{ :a => 1, b: 2 }' }
it { expect(hash_node.mixed_delimiters?).to be_truthy }
end
end
describe '#braces?' do
context 'with braces' do
let(:source) { '{ a: 1, b: 2 }' }
it { expect(hash_node.braces?).to be_truthy }
end
context 'as an argument with no braces' do
let(:source) { 'foo(:bar, a: 1, b: 2)' }
let(:hash_argument) { hash_node.children.last }
it { expect(hash_argument.braces?).to be_falsey }
end
context 'as an argument with braces' do
let(:source) { 'foo(:bar, { a: 1, b: 2 })' }
let(:hash_argument) { hash_node.children.last }
it { expect(hash_argument.braces?).to be_truthy }
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/ast/if_node_spec.rb 0000664 0000000 0000000 00000017574 13070542236 0023307 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::AST::IfNode do
let(:if_node) { parse_source(source).ast }
describe '.new' do
context 'with a regular if statement' do
let(:source) { 'if foo?; :bar; end' }
it { expect(if_node).to be_a(described_class) }
end
context 'with a ternary operator' do
let(:source) { 'foo? ? :bar : :baz' }
it { expect(if_node).to be_a(described_class) }
end
context 'with a modifier statement' do
let(:source) { ':foo if bar?' }
it { expect(if_node).to be_a(described_class) }
end
end
describe '#keyword' do
context 'with an if statement' do
let(:source) { 'if foo?; :bar; end' }
it { expect(if_node.keyword).to eq('if') }
end
context 'with an unless statement' do
let(:source) { 'unless foo?; :bar; end' }
it { expect(if_node.keyword).to eq('unless') }
end
context 'with a ternary operator' do
let(:source) { 'foo? ? :bar : :baz' }
it { expect(if_node.keyword).to eq('') }
end
end
describe '#inverse_keyword?' do
context 'with an if statement' do
let(:source) { 'if foo?; :bar; end' }
it { expect(if_node.inverse_keyword).to eq('unless') }
end
context 'with an unless statement' do
let(:source) { 'unless foo?; :bar; end' }
it { expect(if_node.inverse_keyword).to eq('if') }
end
context 'with a ternary operator' do
let(:source) { 'foo? ? :bar : :baz' }
it { expect(if_node.inverse_keyword).to eq('') }
end
end
describe '#if?' do
context 'with an if statement' do
let(:source) { 'if foo?; :bar; end' }
it { expect(if_node.if?).to be_truthy }
end
context 'with an unless statement' do
let(:source) { 'unless foo?; :bar; end' }
it { expect(if_node.if?).to be_falsey }
end
context 'with a ternary operator' do
let(:source) { 'foo? ? :bar : :baz' }
it { expect(if_node.if?).to be_falsey }
end
end
describe '#unless?' do
context 'with an if statement' do
let(:source) { 'if foo?; :bar; end' }
it { expect(if_node.unless?).to be_falsey }
end
context 'with an unless statement' do
let(:source) { 'unless foo?; :bar; end' }
it { expect(if_node.unless?).to be_truthy }
end
context 'with a ternary operator' do
let(:source) { 'foo? ? :bar : :baz' }
it { expect(if_node.unless?).to be_falsey }
end
end
describe '#ternary?' do
context 'with an if statement' do
let(:source) { 'if foo?; :bar; end' }
it { expect(if_node.ternary?).to be_falsey }
end
context 'with an unless statement' do
let(:source) { 'unless foo?; :bar; end' }
it { expect(if_node.ternary?).to be_falsey }
end
context 'with a ternary operator' do
let(:source) { 'foo? ? :bar : :baz' }
it { expect(if_node.ternary?).to be_truthy }
end
end
describe '#elsif?' do
context 'with an elsif statement' do
let(:source) do
['if foo?',
' 1',
'elsif bar?',
' 2',
'end'].join("\n")
end
let(:elsif_node) { if_node.else_branch }
it { expect(elsif_node.elsif?).to be_truthy }
end
context 'with an if statement comtaining an elsif' do
let(:source) do
['if foo?',
' 1',
'elsif bar?',
' 2',
'end'].join("\n")
end
it { expect(if_node.elsif?).to be_falsey }
end
context 'without an elsif statement' do
let(:source) do
['if foo?',
' 1',
'end'].join("\n")
end
it { expect(if_node.elsif?).to be_falsey }
end
end
describe '#else?' do
context 'with an elsif statement' do
let(:source) do
['if foo?',
' 1',
'elsif bar?',
' 2',
'end'].join("\n")
end
# Note: This is a legacy behaviour.
it { expect(if_node.else?).to be_truthy }
end
context 'without an else statement' do
let(:source) do
['if foo?',
' 1',
'else',
' 2',
'end'].join("\n")
end
it { expect(if_node.elsif?).to be_falsey }
end
end
describe '#modifier_form?' do
context 'with a non-modifier if statement' do
let(:source) { 'if foo?; :bar; end' }
it { expect(if_node.modifier_form?).to be_falsey }
end
context 'with a non-modifier unless statement' do
let(:source) { 'unless foo?; :bar; end' }
it { expect(if_node.modifier_form?).to be_falsey }
end
context 'with a ternary operator' do
let(:source) { 'foo? ? :bar : :baz' }
it { expect(if_node.modifier_form?).to be_falsey }
end
context 'with a modifier if statement' do
let(:source) { ':bar if foo?' }
it { expect(if_node.modifier_form?).to be_truthy }
end
context 'with a modifier unless statement' do
let(:source) { ':bar unless foo?' }
it { expect(if_node.modifier_form?).to be_truthy }
end
end
describe '#nested_conditional?' do
context 'with no nested conditionals' do
let(:source) do
['if foo?',
' 1',
'elsif bar?',
' 2',
'else',
' 3',
'end'].join("\n")
end
it { expect(if_node.nested_conditional?).to be_falsey }
end
context 'with nested conditionals in if clause' do
let(:source) do
['if foo?',
' if baz; 4; end',
'elsif bar?',
' 2',
'else',
' 3',
'end'].join("\n")
end
it { expect(if_node.nested_conditional?).to be_truthy }
end
context 'with nested conditionals in elsif clause' do
let(:source) do
['if foo?',
' 1',
'elsif bar?',
' if baz; 4; end',
'else',
' 3',
'end'].join("\n")
end
it { expect(if_node.nested_conditional?).to be_truthy }
end
context 'with nested conditionals in else clause' do
let(:source) do
['if foo?',
' 1',
'elsif bar?',
' 2',
'else',
' if baz; 4; end',
'end'].join("\n")
end
it { expect(if_node.nested_conditional?).to be_truthy }
end
context 'with nested ternary operators' do
context 'when nested in the truthy branch' do
let(:source) { 'foo? ? bar? ? 1 : 2 : 3' }
it { expect(if_node.nested_conditional?).to be_truthy }
end
context 'when nested in the falsey branch' do
let(:source) { 'foo? ? 3 : bar? ? 1 : 2' }
it { expect(if_node.nested_conditional?).to be_truthy }
end
end
end
describe '#if_branch' do
context 'with an if statement' do
let(:source) do
['if foo?',
' :foo',
'else',
' 42',
'end'].join("\n")
end
it { expect(if_node.if_branch).to be_sym_type }
end
context 'with an unless statement' do
let(:source) do
['unless foo?',
' :foo',
'else',
' 42',
'end'].join("\n")
end
it { expect(if_node.if_branch).to be_sym_type }
end
context 'with a ternary operator' do
let(:source) { 'foo? ? :foo : 42' }
it { expect(if_node.if_branch).to be_sym_type }
end
end
describe '#else_branch' do
context 'with an if statement' do
let(:source) do
['if foo?',
' :foo',
'else',
' 42',
'end'].join("\n")
end
it { expect(if_node.else_branch).to be_int_type }
end
context 'with an unless statement' do
let(:source) do
['unless foo?',
' :foo',
'else',
' 42',
'end'].join("\n")
end
it { expect(if_node.else_branch).to be_int_type }
end
context 'with a ternary operator' do
let(:source) { 'foo? ? :foo : 42' }
it { expect(if_node.else_branch).to be_int_type }
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/ast/keyword_splat_node_spec.rb 0000664 0000000 0000000 00000021454 13070542236 0025570 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::AST::KeywordSplatNode do
let(:kwsplat_node) { parse_source(source).ast.children.last }
describe '.new' do
let(:source) { '{ a: 1, **foo }' }
it { expect(kwsplat_node).to be_a(described_class) }
end
describe '#hash_rocket?' do
let(:source) { '{ a: 1, **foo }' }
it { expect(kwsplat_node.hash_rocket?).to be_falsey }
end
describe '#colon?' do
let(:source) { '{ a: 1, **foo }' }
it { expect(kwsplat_node.colon?).to be_falsey }
end
describe '#key' do
let(:source) { '{ a: 1, **foo }' }
it { expect(kwsplat_node.key).to eq(kwsplat_node) }
end
describe '#value' do
let(:source) { '{ a: 1, **foo }' }
it { expect(kwsplat_node.value).to eq(kwsplat_node) }
end
describe '#operator' do
let(:source) { '{ a: 1, **foo }' }
it { expect(kwsplat_node.operator).to eq('**') }
end
describe '#same_line?' do
let(:first_pair) { parse_source(source).ast.children[0] }
let(:second_pair) { parse_source(source).ast.children[1] }
context 'when both pairs are on the same line' do
let(:source) do
['{',
' a: 1, **foo',
'}'].join("\n")
end
it { expect(first_pair.same_line?(second_pair)).to be_truthy }
end
context 'when a multiline pair shares the same line' do
let(:source) do
['{',
' a: (',
' ), **foo',
'}'].join("\n")
end
it { expect(first_pair.same_line?(second_pair)).to be_truthy }
it { expect(second_pair.same_line?(first_pair)).to be_truthy }
end
context 'when pairs are on separate lines' do
let(:source) do
['{',
' a: 1,',
' **foo',
'}'].join("\n")
end
it { expect(first_pair.same_line?(second_pair)).to be_falsey }
end
end
describe '#key_delta' do
let(:pair_node) { parse_source(source).ast.children[0] }
let(:kwsplat_node) { parse_source(source).ast.children[1] }
context 'with alignment set to :left' do
context 'when using colon delimiters' do
context 'when keyword splat is aligned' do
let(:source) do
['{',
' a: 1,',
' **foo',
'}'].join("\n")
end
it { expect(kwsplat_node.key_delta(pair_node)).to eq(0) }
end
context 'when keyword splat is ahead' do
let(:source) do
['{',
' a: 1,',
' **foo',
'}'].join("\n")
end
it { expect(kwsplat_node.key_delta(pair_node)).to eq(2) }
end
context 'when keyword splat is behind' do
let(:source) do
['{',
' a: 1,',
' **foo',
'}'].join("\n")
end
it { expect(kwsplat_node.key_delta(pair_node)).to eq(-2) }
end
context 'when keyword splat is on the same line' do
let(:source) do
['{',
' a: 1, **foo',
'}'].join("\n")
end
it { expect(kwsplat_node.key_delta(pair_node)).to eq(0) }
end
end
context 'when using hash rocket delimiters' do
context 'when keyword splat is aligned' do
let(:source) do
['{',
' a => 1,',
' **foo',
'}'].join("\n")
end
it { expect(kwsplat_node.key_delta(pair_node)).to eq(0) }
end
context 'when keyword splat is ahead' do
let(:source) do
['{',
' a => 1,',
' **foo',
'}'].join("\n")
end
it { expect(kwsplat_node.key_delta(pair_node)).to eq(2) }
end
context 'when keyword splat is behind' do
let(:source) do
['{',
' a => 1,',
' **foo',
'}'].join("\n")
end
it { expect(kwsplat_node.key_delta(pair_node)).to eq(-2) }
end
context 'when keyword splat is on the same line' do
let(:source) do
['{',
' a => 1, **foo',
'}'].join("\n")
end
it { expect(kwsplat_node.key_delta(pair_node)).to eq(0) }
end
end
end
context 'with alignment set to :right' do
context 'when using colon delimiters' do
context 'when keyword splat is aligned' do
let(:source) do
['{',
' a: 1,',
' **foo',
'}'].join("\n")
end
it { expect(kwsplat_node.key_delta(pair_node, :right)).to eq(0) }
end
context 'when keyword splat is ahead' do
let(:source) do
['{',
' a: 1,',
' **foo',
'}'].join("\n")
end
it { expect(kwsplat_node.key_delta(pair_node, :right)).to eq(0) }
end
context 'when keyword splat is behind' do
let(:source) do
['{',
' a: 1,',
' **foo',
'}'].join("\n")
end
it { expect(kwsplat_node.key_delta(pair_node, :right)).to eq(0) }
end
context 'when keyword splat is on the same line' do
let(:source) do
['{',
' a: 1, **foo',
'}'].join("\n")
end
it { expect(kwsplat_node.key_delta(pair_node, :right)).to eq(0) }
end
end
context 'when using hash rocket delimiters' do
context 'when keyword splat is aligned' do
let(:source) do
['{',
' a => 1,',
' **foo',
'}'].join("\n")
end
it { expect(kwsplat_node.key_delta(pair_node, :right)).to eq(0) }
end
context 'when keyword splat is ahead' do
let(:source) do
['{',
' a => 1,',
' **foo',
'}'].join("\n")
end
it { expect(kwsplat_node.key_delta(pair_node, :right)).to eq(0) }
end
context 'when keyword splat is behind' do
let(:source) do
['{',
' a => 1,',
' **foo',
'}'].join("\n")
end
it { expect(kwsplat_node.key_delta(pair_node, :right)).to eq(0) }
end
context 'when keyword splat is on the same line' do
let(:source) do
['{',
' a => 1, **foo',
'}'].join("\n")
end
it { expect(kwsplat_node.key_delta(pair_node, :right)).to eq(0) }
end
end
end
end
describe '#value_delta' do
let(:pair_node) { parse_source(source).ast.children[0] }
let(:kwsplat_node) { parse_source(source).ast.children[1] }
context 'when using colon delimiters' do
context 'when keyword splat is left aligned' do
let(:source) do
['{',
' a: 1,',
' **foo',
'}'].join("\n")
end
it { expect(kwsplat_node.value_delta(pair_node)).to eq(0) }
end
context 'when keyword splat is ahead' do
let(:source) do
['{',
' a: 1,',
' **foo',
'}'].join("\n")
end
it { expect(kwsplat_node.value_delta(pair_node)).to eq(0) }
end
context 'when keyword splat is behind' do
let(:source) do
['{',
' a: 1,',
' **foo',
'}'].join("\n")
end
it { expect(kwsplat_node.value_delta(pair_node)).to eq(0) }
end
context 'when keyword splat is on the same line' do
let(:source) do
['{',
' a: 1, **foo',
'}'].join("\n")
end
it { expect(kwsplat_node.value_delta(pair_node)).to eq(0) }
end
end
context 'when using hash rocket delimiters' do
context 'when keyword splat is left aligned' do
let(:source) do
['{',
' a => 1,',
' **foo',
'}'].join("\n")
end
it { expect(kwsplat_node.value_delta(pair_node)).to eq(0) }
end
context 'when keyword splat is ahead' do
let(:source) do
['{',
' a => 1,',
' **foo',
'}'].join("\n")
end
it { expect(kwsplat_node.value_delta(pair_node)).to eq(0) }
end
context 'when keyword splat is behind' do
let(:source) do
['{',
' a => 1,',
' **foo',
'}'].join("\n")
end
it { expect(kwsplat_node.value_delta(pair_node)).to eq(0) }
end
context 'when keyword splat is on the same line' do
let(:source) do
['{',
' a => 1, **foo',
'}'].join("\n")
end
it { expect(kwsplat_node.value_delta(pair_node)).to eq(0) }
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/ast/node_spec.rb 0000664 0000000 0000000 00000023066 13070542236 0022622 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::AST::Node do
describe '#asgn_method_call?' do
it 'does not match ==' do
parsed = parse_source('Object.new == value')
expect(parsed.ast.asgn_method_call?).to be(false)
end
it 'does not match !=' do
parsed = parse_source('Object.new != value')
expect(parsed.ast.asgn_method_call?).to be(false)
end
it 'does not match <=' do
parsed = parse_source('Object.new <= value')
expect(parsed.ast.asgn_method_call?).to be(false)
end
it 'does not match >=' do
parsed = parse_source('Object.new >= value')
expect(parsed.ast.asgn_method_call?).to be(false)
end
it 'does not match ===' do
parsed = parse_source('Object.new === value')
expect(parsed.ast.asgn_method_call?).to be(false)
end
it 'matches =' do
parsed = parse_source('Object.new = value')
expect(parsed.ast.asgn_method_call?).to be(true)
end
end
describe '#value_used?' do
let(:node) { RuboCop::ProcessedSource.new(src, ruby_version).ast }
before(:all) do
module RuboCop
module AST
class Node
# Let's make our predicate matchers read better
def used?
value_used?
end
end
end
end
end
context 'at the top level' do
let(:src) { 'expr' }
it 'is false' do
expect(node).not_to be_used
end
end
context 'within a method call node' do
let(:src) { 'obj.method(arg1, arg2, arg3)' }
it 'is always true' do
expect(node.child_nodes).to all(be_used)
end
end
context 'at the end of a block' do
let(:src) { 'obj.method { blah; expr }' }
it 'is always true' do
expect(node.children.last).to be_used
end
end
context 'within a class definition node' do
let(:src) { 'class C < Super; def a; 1; end; self; end' }
it 'is always true' do
expect(node.child_nodes).to all(be_used)
end
end
context 'within a module definition node' do
let(:src) { 'module M; def method; end; 1; end' }
it 'is always true' do
expect(node.child_nodes).to all(be_used)
end
end
context 'within a singleton class node' do
let(:src) { 'class << obj; 1; 2; end' }
it 'is always true' do
expect(node.child_nodes).to all(be_used)
end
end
context 'within an if...else..end node' do
context 'nested in a method call' do
let(:src) { 'obj.method(if a then b else c end)' }
it 'is always true' do
if_node = node.children[2]
expect(if_node.child_nodes).to all(be_used)
end
end
context 'at the top level' do
let(:src) { 'if a then b else c end' }
it 'is true only for the condition' do
condition, true_branch, false_branch = *node
expect(condition).to be_used
expect(true_branch).not_to be_used
expect(false_branch).not_to be_used
end
end
end
context 'within an array literal' do
context 'assigned to an ivar' do
let(:src) { '@var = [a, b, c]' }
it 'is always true' do
ary_node = node.children[1]
expect(ary_node.child_nodes).to all(be_used)
end
end
context 'at the top level' do
let(:src) { '[a, b, c]' }
it 'is always false' do
expect(node.child_nodes.map(&:used?)).to all(be false)
end
end
end
context 'within a while node' do
let(:src) { 'while a; b; end' }
it 'is true only for the condition' do
condition, body = *node
expect(condition).to be_used
expect(body).not_to be_used
end
end
end
describe '#recursive_basic_literal?' do
let(:node) { RuboCop::ProcessedSource.new(src, ruby_version).ast }
shared_examples :literal do |source|
let(:src) { source }
it "returns true for `#{source}`" do
expect(node).to be_recursive_literal
end
end
it_behaves_like :literal, '!true'
it_behaves_like :literal, '"#{2}"'
it_behaves_like :literal, '(1)'
it_behaves_like :literal, '(false && true)'
it_behaves_like :literal, '(false <=> true)'
it_behaves_like :literal, '(false or true)'
it_behaves_like :literal, '[1, 2, 3]'
it_behaves_like :literal, '{ :a => 1, :b => 2 }'
it_behaves_like :literal, '{ a: 1, b: 2 }'
it_behaves_like :literal, '/./'
it_behaves_like :literal, '%r{abx}ixo'
it_behaves_like :literal, '1.0'
it_behaves_like :literal, '1'
it_behaves_like :literal, 'false'
it_behaves_like :literal, 'nil'
it_behaves_like :literal, "'str'"
shared_examples :non_literal do |source|
let(:src) { source }
it "returns false for `#{source}`" do
expect(node).not_to be_recursive_literal
end
end
it_behaves_like :non_literal, '(x && false)'
it_behaves_like :non_literal, '(x == false)'
it_behaves_like :non_literal, '(x or false)'
it_behaves_like :non_literal, '[some_method_call]'
it_behaves_like :non_literal, '{ :sym => some_method_call }'
it_behaves_like :non_literal, '{ some_method_call => :sym }'
it_behaves_like :non_literal, '/.#{some_method_call}/'
it_behaves_like :non_literal, '%r{abx#{foo}}ixo'
it_behaves_like :non_literal, 'some_method_call'
it_behaves_like :non_literal, 'some_method_call(x, y)'
end
describe '#pure?' do
let(:node) { RuboCop::ProcessedSource.new(src, ruby_version).ast }
context 'for a method call' do
let(:src) { 'obj.method(arg1, arg2)' }
it 'returns false' do
expect(node).not_to be_pure
end
end
context 'for an integer literal' do
let(:src) { '100' }
it 'returns true' do
expect(node).to be_pure
end
end
context 'for an array literal' do
context 'with only literal children' do
let(:src) { '[1..100, false, :symbol, "string", 1.0]' }
it 'returns true' do
expect(node).to be_pure
end
end
context 'which contains a method call' do
let(:src) { '[1, 2, 3, 3 + 4]' }
it 'returns false' do
expect(node).not_to be_pure
end
end
end
context 'for a hash literal' do
context 'with only literal children' do
let(:src) { '{range: 1..100, bool: false, str: "string", float: 1.0}' }
it 'returns true' do
expect(node).to be_pure
end
end
context 'which contains a method call' do
let(:src) { '{a: 1, b: 2, c: Kernel.exit}' }
it 'returns false' do
expect(node).not_to be_pure
end
end
end
context 'for a nested if' do
context 'where the innermost descendants are local vars and literals' do
let(:src) do
['lvar1, lvar2 = method1, method2',
'if $global',
' if @initialized',
' [lvar1, lvar2, true]',
' else',
' :symbol',
' end',
'else',
' lvar1',
'end'].join("\n")
end
it 'returns true' do
if_node = node.children[1]
expect(if_node.type).to be :if
expect(if_node).to be_pure
end
end
context 'where one branch contains a method call' do
let(:src) { 'if $DEBUG then puts "hello" else nil end' }
it 'returns false' do
expect(node).not_to be_pure
end
end
context 'where one branch contains an assignment statement' do
let(:src) { 'if @a then 1 else $global = "str" end' }
it 'returns false' do
expect(node).not_to be_pure
end
end
end
context 'for an ivar assignment' do
let(:src) { '@var = 1' }
it 'returns false' do
expect(node).not_to be_pure
end
end
context 'for a gvar assignment' do
let(:src) { '$var = 1' }
it 'returns false' do
expect(node).not_to be_pure
end
end
context 'for a cvar assignment' do
let(:src) { '@@var = 1' }
it 'returns false' do
expect(node).not_to be_pure
end
end
context 'for an lvar assignment' do
let(:src) { 'var = 1' }
it 'returns false' do
expect(node).not_to be_pure
end
end
context 'for a class definition' do
let(:src) { 'class C < Super; def method; end end' }
it 'returns false' do
expect(node).not_to be_pure
end
end
context 'for a module definition' do
let(:src) { 'module M; def method; end end' }
it 'returns false' do
expect(node).not_to be_pure
end
end
context 'for a regexp' do
let(:opts) { '' }
let(:body) { '' }
let(:src) { "/#{body}/#{opts}" }
context 'with interpolated segments' do
let(:body) { '#{x}' }
it 'returns false' do
expect(node).not_to be_pure
end
end
context 'with no interpolation' do
let(:src) { URI.regexp.inspect }
it 'returns true' do
expect(node).to be_pure
end
end
context 'with options' do
let(:opts) { 'oix' }
it 'returns true' do
expect(node).to be_pure
end
end
end
end
describe '#sibling_index' do
let(:node) { RuboCop::ProcessedSource.new(src, ruby_version).ast }
let(:src) do
[
'def foo; end',
'def bar; end',
'def baz; end'
].join("\n")
end
it 'returns its sibling index' do
(0..2).each do |n|
expect(node.children[n].sibling_index).to eq(n)
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/ast/or_node_spec.rb 0000664 0000000 0000000 00000005556 13070542236 0023326 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::AST::OrNode do
let(:or_node) { parse_source(source).ast }
describe '.new' do
context 'with a logical or node' do
let(:source) do
':foo || :bar'
end
it { expect(or_node).to be_a(described_class) }
end
context 'with a semantic or node' do
let(:source) do
':foo or :bar'
end
it { expect(or_node).to be_a(described_class) }
end
end
describe '#logical_operator?' do
context 'with a logical or node' do
let(:source) do
':foo || :bar'
end
it { expect(or_node).to be_logical_operator }
end
context 'with a semantic or node' do
let(:source) do
':foo or :bar'
end
it { expect(or_node).not_to be_logical_operator }
end
end
describe '#semantic_operator?' do
context 'with a logical or node' do
let(:source) do
':foo || :bar'
end
it { expect(or_node).not_to be_semantic_operator }
end
context 'with a semantic or node' do
let(:source) do
':foo or :bar'
end
it { expect(or_node).to be_semantic_operator }
end
end
describe '#operator' do
context 'with a logical or node' do
let(:source) do
':foo || :bar'
end
it { expect(or_node.operator).to eq('||') }
end
context 'with a semantic or node' do
let(:source) do
':foo or :bar'
end
it { expect(or_node.operator).to eq('or') }
end
end
describe '#alternate_operator' do
context 'with a logical or node' do
let(:source) do
':foo || :bar'
end
it { expect(or_node.alternate_operator).to eq('or') }
end
context 'with a semantic or node' do
let(:source) do
':foo or :bar'
end
it { expect(or_node.alternate_operator).to eq('||') }
end
end
describe '#inverse_operator' do
context 'with a logical or node' do
let(:source) do
':foo || :bar'
end
it { expect(or_node.inverse_operator).to eq('&&') }
end
context 'with a semantic or node' do
let(:source) do
':foo or :bar'
end
it { expect(or_node.inverse_operator).to eq('and') }
end
end
describe '#lhs' do
context 'with a logical or node' do
let(:source) do
':foo || 42'
end
it { expect(or_node.lhs).to be_sym_type }
end
context 'with a semantic or node' do
let(:source) do
':foo or 42'
end
it { expect(or_node.lhs).to be_sym_type }
end
end
describe '#rhs' do
context 'with a logical or node' do
let(:source) do
':foo || 42'
end
it { expect(or_node.rhs).to be_int_type }
end
context 'with a semantic or node' do
let(:source) do
':foo or 42'
end
it { expect(or_node.rhs).to be_int_type }
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/ast/pair_node_spec.rb 0000664 0000000 0000000 00000043764 13070542236 0023644 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::AST::PairNode do
let(:pair_node) { parse_source(source).ast.children.first }
describe '.new' do
let(:source) { '{ a: 1 }' }
it { expect(pair_node).to be_a(described_class) }
end
describe '#hash_rocket?' do
context 'when using a hash rocket delimiter' do
let(:source) { '{ a => 1 }' }
it { expect(pair_node.hash_rocket?).to be_truthy }
end
context 'when using a colon delimiter' do
let(:source) { '{ a: 1 }' }
it { expect(pair_node.hash_rocket?).to be_falsey }
end
end
describe '#colon?' do
context 'when using a hash rocket delimiter' do
let(:source) { '{ a => 1 }' }
it { expect(pair_node.colon?).to be_falsey }
end
context 'when using a colon delimiter' do
let(:source) { '{ a: 1 }' }
it { expect(pair_node.colon?).to be_truthy }
end
end
describe '#colon?' do
context 'when using a hash rocket delimiter' do
let(:source) { '{ a => 1 }' }
it { expect(pair_node.colon?).to be_falsey }
end
context 'when using a colon delimiter' do
let(:source) { '{ a: 1 }' }
it { expect(pair_node.colon?).to be_truthy }
end
end
describe '#delimiter' do
context 'when using a hash rocket delimiter' do
let(:source) { '{ a => 1 }' }
it { expect(pair_node.delimiter).to eq('=>') }
it { expect(pair_node.delimiter(true)).to eq(' => ') }
end
context 'when using a colon delimiter' do
let(:source) { '{ a: 1 }' }
it { expect(pair_node.delimiter).to eq(':') }
it { expect(pair_node.delimiter(true)).to eq(': ') }
end
end
describe '#inverse_delimiter' do
context 'when using a hash rocket delimiter' do
let(:source) { '{ a => 1 }' }
it { expect(pair_node.inverse_delimiter).to eq(':') }
it { expect(pair_node.inverse_delimiter(true)).to eq(': ') }
end
context 'when using a colon delimiter' do
let(:source) { '{ a: 1 }' }
it { expect(pair_node.inverse_delimiter).to eq('=>') }
it { expect(pair_node.inverse_delimiter(true)).to eq(' => ') }
end
end
describe '#key' do
context 'when using a symbol key' do
let(:source) { '{ a: 1 }' }
it { expect(pair_node.key).to be_sym_type }
end
context 'when using a string key' do
let(:source) { "{ 'a' => 1 }" }
it { expect(pair_node.key).to be_str_type }
end
end
describe '#value' do
let(:source) { '{ a: 1 }' }
it { expect(pair_node.value).to be_int_type }
end
describe '#same_line?' do
let(:first_pair) { parse_source(source).ast.children[0] }
let(:second_pair) { parse_source(source).ast.children[1] }
context 'when both pairs are on the same line' do
context 'when both pairs are explicit pairs' do
let(:source) do
['{',
' a: 1, b: 2',
'}'].join("\n")
end
it { expect(first_pair.same_line?(second_pair)).to be_truthy }
end
context 'when both pair is a keyword splat' do
let(:source) do
['{',
' a: 1, **foo',
'}'].join("\n")
end
it { expect(first_pair.same_line?(second_pair)).to be_truthy }
end
end
context 'when a multiline pair shares the same line' do
context 'when both pairs are explicit pairs' do
let(:source) do
['{',
' a: (',
' ), b: 2',
'}'].join("\n")
end
it { expect(first_pair.same_line?(second_pair)).to be_truthy }
it { expect(second_pair.same_line?(first_pair)).to be_truthy }
end
context 'when last pair is a keyword splat' do
let(:source) do
['{',
' a: (',
' ), **foo',
'}'].join("\n")
end
it { expect(first_pair.same_line?(second_pair)).to be_truthy }
it { expect(second_pair.same_line?(first_pair)).to be_truthy }
end
end
context 'when pairs are on separate lines' do
context 'when both pairs are explicit pairs' do
let(:source) do
['{',
' a: 1,',
' b: 2',
'}'].join("\n")
end
it { expect(first_pair.same_line?(second_pair)).to be_falsey }
end
context 'when last pair is a keyword splat' do
let(:source) do
['{',
' a: 1,',
' **foo',
'}'].join("\n")
end
it { expect(first_pair.same_line?(second_pair)).to be_falsey }
end
end
end
describe '#key_delta' do
let(:first_pair) { parse_source(source).ast.children[0] }
let(:second_pair) { parse_source(source).ast.children[1] }
context 'with alignment set to :left' do
context 'when using colon delimiters' do
context 'when keys are aligned' do
context 'when both pairs are explicit pairs' do
let(:source) do
['{',
' a: 1,',
' b: 2',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair)).to eq(0) }
end
context 'when second pair is a keyword splat' do
let(:source) do
['{',
' a: 1,',
' **foo',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair)).to eq(0) }
end
end
context 'when receiver key is behind' do
context 'when both pairs are reail pairs' do
let(:source) do
['{',
' a: 1,',
' b: 2',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair)).to eq(-2) }
end
context 'when second pair is a keyword splat' do
let(:source) do
['{',
' a: 1,',
' **foo',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair)).to eq(-2) }
end
end
context 'when receiver key is ahead' do
context 'when both pairs are explicit pairs' do
let(:source) do
['{',
' a: 1,',
' b: 2',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair)).to eq(2) }
end
context 'when second pair is a keyword splat' do
let(:source) do
['{',
' a: 1,',
' **foo',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair)).to eq(2) }
end
end
context 'when both keys are on the same line' do
context 'when both pairs are explicit pairs' do
let(:source) do
['{',
' a: 1, b: 2',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair)).to eq(0) }
end
context 'when second pair is a keyword splat' do
let(:source) do
['{',
' a: 1, **foo',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair)).to eq(0) }
end
end
end
context 'when using hash rocket delimiters' do
context 'when keys are aligned' do
context 'when both keys are explicit keys' do
let(:source) do
['{',
' a => 1,',
' b => 2',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair)).to eq(0) }
end
context 'when second key is a keyword splat' do
let(:source) do
['{',
' a => 1,',
' **foo',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair)).to eq(0) }
end
end
context 'when receiver key is behind' do
context 'when both pairs are explicit pairs' do
let(:source) do
['{',
' a => 1,',
' b => 2',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair)).to eq(-2) }
end
context 'when second pair is a keyword splat' do
let(:source) do
['{',
' a => 1,',
' **foo',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair)).to eq(-2) }
end
end
context 'when receiver key is ahead' do
context 'when both pairs are explicit pairs' do
let(:source) do
['{',
' a => 1,',
' b => 2',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair)).to eq(2) }
end
context 'when second pair is a keyword splat' do
let(:source) do
['{',
' a => 1,',
' **foo',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair)).to eq(2) }
end
end
context 'when both keys are on the same line' do
context 'when both pairs are explicit pairs' do
let(:source) do
['{',
' a => 1, b => 2',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair)).to eq(0) }
end
context 'when second pair is a keyword splat' do
let(:source) do
['{',
' a => 1, **foo',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair)).to eq(0) }
end
end
end
end
context 'with alignment set to :right' do
context 'when using colon delimiters' do
context 'when keys are aligned' do
context 'when both pairs are explicit pairs' do
let(:source) do
['{',
' a: 1,',
' b: 2',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair, :right)).to eq(0) }
end
context 'when second pair is a keyword splat' do
let(:source) do
['{',
' a: 1,',
' **foo',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair, :right)).to eq(0) }
end
end
context 'when receiver key is behind' do
context 'when both pairs are reail pairs' do
let(:source) do
['{',
' a: 1,',
' b: 2',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair, :right)).to eq(-2) }
end
context 'when second pair is a keyword splat' do
let(:source) do
['{',
' a: 1,',
' **foo',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair, :right)).to eq(0) }
end
end
context 'when receiver key is ahead' do
context 'when both pairs are explicit pairs' do
let(:source) do
['{',
' a: 1,',
' b: 2',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair, :right)).to eq(2) }
end
context 'when second pair is a keyword splat' do
let(:source) do
['{',
' a: 1,',
' **foo',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair, :right)).to eq(0) }
end
end
context 'when both keys are on the same line' do
context 'when both pairs are explicit pairs' do
let(:source) do
['{',
' a: 1, b: 2',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair, :right)).to eq(0) }
end
context 'when second pair is a keyword splat' do
let(:source) do
['{',
' a: 1, **foo',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair, :right)).to eq(0) }
end
end
end
context 'when using hash rocket delimiters' do
context 'when keys are aligned' do
context 'when both keys are explicit keys' do
let(:source) do
['{',
' a => 1,',
' b => 2',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair, :right)).to eq(0) }
end
context 'when second key is a keyword splat' do
let(:source) do
['{',
' a => 1,',
' **foo',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair, :right)).to eq(0) }
end
end
context 'when receiver key is behind' do
context 'when both pairs are explicit pairs' do
let(:source) do
['{',
' a => 1,',
' b => 2',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair, :right)).to eq(-2) }
end
context 'when second pair is a keyword splat' do
let(:source) do
['{',
' a => 1,',
' **foo',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair, :right)).to eq(0) }
end
end
context 'when receiver key is ahead' do
context 'when both pairs are explicit pairs' do
let(:source) do
['{',
' a => 1,',
' b => 2',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair, :right)).to eq(2) }
end
context 'when second pair is a keyword splat' do
let(:source) do
['{',
' a => 1,',
' **foo',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair, :right)).to eq(0) }
end
end
context 'when both keys are on the same line' do
context 'when both pairs are explicit pairs' do
let(:source) do
['{',
' a => 1, b => 2',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair, :right)).to eq(0) }
end
context 'when second pair is a keyword splat' do
let(:source) do
['{',
' a => 1, **foo',
'}'].join("\n")
end
it { expect(first_pair.key_delta(second_pair, :right)).to eq(0) }
end
end
end
end
end
describe '#value_delta' do
let(:first_pair) { parse_source(source).ast.children[0] }
let(:second_pair) { parse_source(source).ast.children[1] }
context 'when using colon delimiters' do
context 'when values are aligned' do
context 'when both pairs are explicit pairs' do
let(:source) do
['{',
' a: 1,',
' b: 2',
'}'].join("\n")
end
it { expect(first_pair.value_delta(second_pair)).to eq(0) }
end
context 'when second pair is a keyword splat' do
let(:source) do
['{',
' a: 1,',
' **foo',
'}'].join("\n")
end
it { expect(first_pair.value_delta(second_pair)).to eq(0) }
end
end
context 'when receiver value is behind' do
let(:source) do
['{',
' a: 1,',
' b: 2',
'}'].join("\n")
end
it { expect(first_pair.value_delta(second_pair)).to eq(-2) }
end
context 'when receiver value is ahead' do
let(:source) do
['{',
' a: 1,',
' b: 2',
'}'].join("\n")
end
it { expect(first_pair.value_delta(second_pair)).to eq(2) }
end
context 'when both pairs are on the same line' do
let(:source) do
['{',
' a: 1, b: 2',
'}'].join("\n")
end
it { expect(first_pair.value_delta(second_pair)).to eq(0) }
end
end
context 'when using hash rocket delimiters' do
context 'when values are aligned' do
context 'when both pairs are explicit pairs' do
let(:source) do
['{',
' a => 1,',
' b => 2',
'}'].join("\n")
end
it { expect(first_pair.value_delta(second_pair)).to eq(0) }
end
context 'when second pair is a keyword splat' do
let(:source) do
['{',
' a => 1,',
' **foo',
'}'].join("\n")
end
it { expect(first_pair.value_delta(second_pair)).to eq(0) }
end
end
context 'when receiver value is behind' do
let(:source) do
['{',
' a => 1,',
' b => 2',
'}'].join("\n")
end
it { expect(first_pair.value_delta(second_pair)).to eq(-2) }
end
context 'when receiver value is ahead' do
let(:source) do
['{',
' a => 1,',
' b => 2',
'}'].join("\n")
end
it { expect(first_pair.value_delta(second_pair)).to eq(2) }
end
context 'when both pairs are on the same line' do
let(:source) do
['{',
' a => 1, b => 2',
'}'].join("\n")
end
it { expect(first_pair.value_delta(second_pair)).to eq(0) }
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/ast/resbody_node_spec.rb 0000664 0000000 0000000 00000001003 13070542236 0024334 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::AST::ResbodyNode do
let(:resbody_node) do
begin_node = parse_source(source).ast
rescue_node, = *begin_node
rescue_node.children[1]
end
describe '.new' do
let(:source) { 'begin; beginbody; rescue; rescuebody; end' }
it { expect(resbody_node).to be_a(described_class) }
end
describe '#body' do
let(:source) { 'begin; beginbody; rescue Error => ex; :rescuebody; end' }
it { expect(resbody_node.body).to be_sym_type }
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/ast/send_node_spec.rb 0000664 0000000 0000000 00000034101 13070542236 0023623 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::AST::SendNode do
let(:send_node) { parse_source(source).ast }
describe '.new' do
let(:source) { 'foo.bar(:baz)' }
it { expect(send_node).to be_a(described_class) }
end
describe '#receiver' do
context 'with no receiver' do
let(:source) { 'bar(:baz)' }
it { expect(send_node.receiver).to be_nil }
end
context 'with a literal receiver' do
let(:source) { "'foo'.bar(:baz)" }
it { expect(send_node.receiver).to be_str_type }
end
context 'with a variable receiver' do
let(:source) { 'foo.bar(:baz)' }
it { expect(send_node.receiver).to be_send_type }
end
end
describe '#method_name' do
context 'with a plain method' do
let(:source) { 'bar(:baz)' }
it { expect(send_node.method_name).to eq(:bar) }
end
context 'with a setter method' do
let(:source) { 'foo.bar = :baz' }
it { expect(send_node.method_name).to eq(:bar=) }
end
context 'with an operator method' do
let(:source) { 'foo == bar' }
it { expect(send_node.method_name).to eq(:==) }
end
context 'with an implicit call method' do
let(:source) { 'foo.(:baz)' }
it { expect(send_node.method_name).to eq(:call) }
end
end
describe '#method?' do
context 'when message matches' do
context 'when argument is a symbol' do
let(:source) { 'bar(:baz)' }
it { expect(send_node.method?(:bar)).to be_truthy }
end
context 'when argument is a string' do
let(:source) { 'bar(:baz)' }
it { expect(send_node.method?('bar')).to be_truthy }
end
end
context 'when message does not match' do
context 'when argument is a symbol' do
let(:source) { 'bar(:baz)' }
it { expect(send_node.method?(:foo)).to be_falsey }
end
context 'when argument is a string' do
let(:source) { 'bar(:baz)' }
it { expect(send_node.method?('foo')).to be_falsey }
end
end
end
describe '#macro?' do
context 'without a receiver' do
context 'when parent is a class' do
let(:send_node) { parse_source(source).ast.children[2].children[0] }
let(:source) do
['class Foo',
' bar :baz',
' bar :qux',
'end'].join("\n")
end
it { expect(send_node.macro?).to be_truthy }
end
context 'when parent is a module' do
let(:send_node) { parse_source(source).ast.children[1].children[0] }
let(:source) do
['module Foo',
' bar :baz',
' bar :qux',
'end'].join("\n")
end
it { expect(send_node.macro?).to be_truthy }
end
context 'when parent is a method definition' do
let(:send_node) { parse_source(source).ast.children[2] }
let(:source) do
['def foo',
' bar :baz',
'end'].join("\n")
end
it { expect(send_node.macro?).to be_falsey }
end
context 'without a parent' do
let(:source) { 'bar :baz' }
it { expect(send_node.macro?).to be_falsey }
end
end
context 'with a receiver' do
context 'when parent is a class' do
let(:send_node) { parse_source(source).ast.children[2] }
let(:source) do
['class Foo',
' qux.bar :baz',
'end'].join("\n")
end
it { expect(send_node.macro?).to be_falsey }
end
context 'when parent is a module' do
let(:send_node) { parse_source(source).ast.children[1] }
let(:source) do
['module Foo',
' qux.bar :baz',
'end'].join("\n")
end
it { expect(send_node.macro?).to be_falsey }
end
end
end
describe '#command?' do
context 'when argument is a symbol' do
context 'with an explicit receiver' do
let(:source) { 'foo.bar(:baz)' }
it { expect(send_node.command?(:bar)).to be_falsey }
end
context 'with an implicit receiver' do
let(:source) { 'bar(:baz)' }
it { expect(send_node.command?(:bar)).to be_truthy }
end
end
context 'when argument is a string' do
context 'with an explicit receiver' do
let(:source) { 'foo.bar(:baz)' }
it { expect(send_node.command?('bar')).to be_falsey }
end
context 'with an implicit receiver' do
let(:source) { 'bar(:baz)' }
it { expect(send_node.command?('bar')).to be_truthy }
end
end
end
describe '#arguments' do
context 'with no arguments' do
let(:source) { 'foo.bar' }
it { expect(send_node.arguments).to be_empty }
end
context 'with a single literal argument' do
let(:source) { 'foo.bar(:baz)' }
it { expect(send_node.arguments.size).to eq(1) }
end
context 'with a single splat argument' do
let(:source) { 'foo.bar(*baz)' }
it { expect(send_node.arguments.size).to eq(1) }
end
context 'with multiple literal arguments' do
let(:source) { 'foo.bar(:baz, :qux)' }
it { expect(send_node.arguments.size).to eq(2) }
end
context 'with multiple mixed arguments' do
let(:source) { 'foo.bar(:baz, *qux)' }
it { expect(send_node.arguments.size).to eq(2) }
end
end
describe '#first_argument' do
context 'with no arguments' do
let(:source) { 'foo.bar' }
it { expect(send_node.first_argument).to be_nil }
end
context 'with a single literal argument' do
let(:source) { 'foo.bar(:baz)' }
it { expect(send_node.first_argument).to be_sym_type }
end
context 'with a single splat argument' do
let(:source) { 'foo.bar(*baz)' }
it { expect(send_node.first_argument).to be_splat_type }
end
context 'with multiple literal arguments' do
let(:source) { 'foo.bar(:baz, :qux)' }
it { expect(send_node.first_argument).to be_sym_type }
end
context 'with multiple mixed arguments' do
let(:source) { 'foo.bar(:baz, *qux)' }
it { expect(send_node.first_argument).to be_sym_type }
end
end
describe '#last_argument' do
context 'with no arguments' do
let(:source) { 'foo.bar' }
it { expect(send_node.last_argument).to be_nil }
end
context 'with a single literal argument' do
let(:source) { 'foo.bar(:baz)' }
it { expect(send_node.last_argument).to be_sym_type }
end
context 'with a single splat argument' do
let(:source) { 'foo.bar(*baz)' }
it { expect(send_node.last_argument).to be_splat_type }
end
context 'with multiple literal arguments' do
let(:source) { 'foo.bar(:baz, :qux)' }
it { expect(send_node.last_argument).to be_sym_type }
end
context 'with multiple mixed arguments' do
let(:source) { 'foo.bar(:baz, *qux)' }
it { expect(send_node.last_argument).to be_splat_type }
end
end
describe '#arguments?' do
context 'with no arguments' do
let(:source) { 'foo.bar' }
it { expect(send_node.arguments?).to be_falsey }
end
context 'with a single literal argument' do
let(:source) { 'foo.bar(:baz)' }
it { expect(send_node.arguments?).to be_truthy }
end
context 'with a single splat argument' do
let(:source) { 'foo.bar(*baz)' }
it { expect(send_node.arguments?).to be_truthy }
end
context 'with multiple literal arguments' do
let(:source) { 'foo.bar(:baz, :qux)' }
it { expect(send_node.arguments?).to be_truthy }
end
context 'with multiple mixed arguments' do
let(:source) { 'foo.bar(:baz, *qux)' }
it { expect(send_node.arguments?).to be_truthy }
end
end
describe '#parenthesized?' do
context 'with no arguments' do
context 'when not using parentheses' do
let(:source) { 'foo.bar' }
it { expect(send_node.parenthesized?).to be_falsey }
end
context 'when using parentheses' do
let(:source) { 'foo.bar()' }
it { expect(send_node.parenthesized?).to be_truthy }
end
end
context 'with arguments' do
context 'when not using parentheses' do
let(:source) { 'foo.bar :baz' }
it { expect(send_node.parenthesized?).to be_falsey }
end
context 'when using parentheses' do
let(:source) { 'foo.bar(:baz)' }
it { expect(send_node.parenthesized?).to be_truthy }
end
end
end
describe '#setter_method?' do
context 'with a setter method' do
let(:source) { 'foo.bar = :baz' }
it { expect(send_node.setter_method?).to be_truthy }
end
context 'with an indexed setter method' do
let(:source) { 'foo.bar[:baz] = :qux' }
it { expect(send_node.setter_method?).to be_truthy }
end
context 'with an operator method' do
let(:source) { 'foo.bar + 1' }
it { expect(send_node.setter_method?).to be_falsey }
end
context 'with a regular method' do
let(:source) { 'foo.bar(:baz)' }
it { expect(send_node.setter_method?).to be_falsey }
end
end
describe '#operator_method?' do
context 'with a binary operator method' do
let(:source) { 'foo.bar == :baz' }
it { expect(send_node.operator_method?).to be_truthy }
end
context 'with a unary operator method' do
let(:source) { '!foo.bar' }
it { expect(send_node.operator_method?).to be_truthy }
end
context 'with a setter method' do
let(:source) { 'foo.bar = :baz' }
it { expect(send_node.operator_method?).to be_falsey }
end
context 'with a regular method' do
let(:source) { 'foo.bar(:baz)' }
it { expect(send_node.operator_method?).to be_falsey }
end
end
describe '#dot?' do
context 'with a dot' do
let(:source) { 'foo.+ 1' }
it { expect(send_node.dot?).to be_truthy }
end
context 'without a dot' do
let(:source) { 'foo + 1' }
it { expect(send_node.dot?).to be_falsey }
end
context 'with a double colon' do
let(:source) { 'Foo::bar' }
it { expect(send_node.dot?).to be_falsey }
end
context 'with a unary method' do
let(:source) { '!foo.bar' }
it { expect(send_node.dot?).to be_falsey }
end
end
describe '#double_colon?' do
context 'with a double colon' do
let(:source) { 'Foo::bar' }
it { expect(send_node.double_colon?).to be_truthy }
end
context 'with a dot' do
let(:source) { 'foo.+ 1' }
it { expect(send_node.double_colon?).to be_falsey }
end
context 'without a dot' do
let(:source) { 'foo + 1' }
it { expect(send_node.double_colon?).to be_falsey }
end
context 'with a unary method' do
let(:source) { '!foo.bar' }
it { expect(send_node.double_colon?).to be_falsey }
end
end
describe '#self_receiver?' do
context 'with a self receiver' do
let(:source) { 'self.bar' }
it { expect(send_node.self_receiver?).to be_truthy }
end
context 'with a non-self receiver' do
let(:source) { 'foo.bar' }
it { expect(send_node.self_receiver?).to be_falsey }
end
context 'with an implicit receiver' do
let(:source) { 'bar' }
it { expect(send_node.self_receiver?).to be_falsey }
end
end
describe '#implicit_call?' do
context 'with an implicit call method' do
let(:source) { 'foo.(:bar)' }
it { expect(send_node.implicit_call?).to be_truthy }
end
context 'with an explicit call method' do
let(:source) { 'foo.call(:bar)' }
it { expect(send_node.implicit_call?).to be_falsey }
end
context 'with a regular method' do
let(:source) { 'foo.bar' }
it { expect(send_node.implicit_call?).to be_falsey }
end
end
describe '#predicate_method?' do
context 'with a predicate method' do
let(:source) { 'foo.bar?' }
it { expect(send_node.predicate_method?).to be_truthy }
end
context 'with a bang method' do
let(:source) { 'foo.bar!' }
it { expect(send_node.predicate_method?).to be_falsey }
end
context 'with a regular method' do
let(:source) { 'foo.bar' }
it { expect(send_node.predicate_method?).to be_falsey }
end
end
describe '#bang_method?' do
context 'with a bang method' do
let(:source) { 'foo.bar!' }
it { expect(send_node.bang_method?).to be_truthy }
end
context 'with a predicate method' do
let(:source) { 'foo.bar?' }
it { expect(send_node.bang_method?).to be_falsey }
end
context 'with a regular method' do
let(:source) { 'foo.bar' }
it { expect(send_node.bang_method?).to be_falsey }
end
end
describe '#camel_case_method?' do
context 'with a camel case method' do
let(:source) { 'Integer(1.0)' }
it { expect(send_node.camel_case_method?).to be_truthy }
end
context 'with a regular method' do
let(:source) { 'integer(1.0)' }
it { expect(send_node.camel_case_method?).to be_falsey }
end
end
describe '#block_argument?' do
context 'with a block argument' do
let(:source) { 'foo.bar(&baz)' }
it { expect(send_node.block_argument?).to be_truthy }
end
context 'with no arguments' do
let(:source) { 'foo.bar' }
it { expect(send_node.block_argument?).to be_falsey }
end
context 'with regular arguments' do
let(:source) { 'foo.bar(:baz)' }
it { expect(send_node.block_argument?).to be_falsey }
end
context 'with mixed arguments' do
let(:source) { 'foo.bar(:baz, &qux)' }
it { expect(send_node.block_argument?).to be_truthy }
end
end
describe '#splat_argument?' do
context 'with a splat argument' do
let(:source) { 'foo.bar(*baz)' }
it { expect(send_node.splat_argument?).to be_truthy }
end
context 'with no arguments' do
let(:source) { 'foo.bar' }
it { expect(send_node.splat_argument?).to be_falsey }
end
context 'with regular arguments' do
let(:source) { 'foo.bar(:baz)' }
it { expect(send_node.splat_argument?).to be_falsey }
end
context 'with mixed arguments' do
let(:source) { 'foo.bar(:baz, *qux)' }
it { expect(send_node.splat_argument?).to be_truthy }
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/ast/until_node_spec.rb 0000664 0000000 0000000 00000002017 13070542236 0024026 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::AST::UntilNode do
let(:until_node) { parse_source(source).ast }
describe '.new' do
context 'with a statement until' do
let(:source) { 'until foo; bar; end' }
it { expect(until_node).to be_a(described_class) }
end
context 'with a modifier until' do
let(:source) { 'begin foo; end until bar' }
it { expect(until_node).to be_a(described_class) }
end
end
describe '#keyword' do
let(:source) { 'until foo; bar; end' }
it { expect(until_node.keyword).to eq('until') }
end
describe '#inverse_keyword' do
let(:source) { 'until foo; bar; end' }
it { expect(until_node.inverse_keyword).to eq('while') }
end
describe '#do?' do
context 'with a do keyword' do
let(:source) { 'until foo do; bar; end' }
it { expect(until_node.do?).to be_truthy }
end
context 'without a do keyword' do
let(:source) { 'until foo; bar; end' }
it { expect(until_node.do?).to be_falsey }
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/ast/when_node_spec.rb 0000664 0000000 0000000 00000005203 13070542236 0023634 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::AST::WhenNode do
let(:when_node) { parse_source(source).ast.children[1] }
describe '.new' do
let(:source) do
['case',
'when :foo then bar',
'end'].join("\n")
end
it { expect(when_node).to be_a(described_class) }
end
describe '#conditions' do
context 'with a single condition' do
let(:source) do
['case',
'when :foo then bar',
'end'].join("\n")
end
it { expect(when_node.conditions.size).to eq(1) }
it { expect(when_node.conditions).to all(be_literal) }
end
context 'with a multiple conditions' do
let(:source) do
['case',
'when :foo, :bar, :baz then bar',
'end'].join("\n")
end
it { expect(when_node.conditions.size).to eq(3) }
it { expect(when_node.conditions).to all(be_literal) }
end
end
describe '#each_condition' do
let(:source) do
['case',
'when :foo, :bar, :baz then bar',
'end'].join("\n")
end
context 'when not passed a block' do
it { expect(when_node.each_condition).to be_an(Enumerator) }
end
context 'when passed a block' do
it 'yields all the conditions' do
expect { |b| when_node.each_condition(&b) }
.to yield_successive_args(*when_node.conditions)
end
end
end
describe '#then?' do
context 'with a then keyword' do
let(:source) do
['case',
'when :foo then bar',
'end'].join("\n")
end
it { expect(when_node.then?).to be_truthy }
end
context 'without a then keyword' do
let(:source) do
['case',
'when :foo',
' bar',
'end'].join("\n")
end
it { expect(when_node.then?).to be_falsey }
end
end
describe '#body' do
context 'with a then keyword' do
let(:source) do
['case',
'when :foo then :bar',
'end'].join("\n")
end
it { expect(when_node.body).to be_sym_type }
end
context 'without a then keyword' do
let(:source) do
['case',
'when :foo',
' [:bar, :baz]',
'end'].join("\n")
end
it { expect(when_node.body).to be_array_type }
end
end
describe '#branch_index' do
let(:source) do
['case',
'when :foo then 1',
'when :bar then 2',
'when :baz then 3',
'end'].join("\n")
end
let(:whens) { parse_source(source).ast.children[1...-1] }
it { expect(whens[0].branch_index).to eq(0) }
it { expect(whens[1].branch_index).to eq(1) }
it { expect(whens[2].branch_index).to eq(2) }
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/ast/while_node_spec.rb 0000664 0000000 0000000 00000002017 13070542236 0024003 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::AST::WhileNode do
let(:while_node) { parse_source(source).ast }
describe '.new' do
context 'with a statement while' do
let(:source) { 'while foo; bar; end' }
it { expect(while_node).to be_a(described_class) }
end
context 'with a modifier while' do
let(:source) { 'begin foo; end while bar' }
it { expect(while_node).to be_a(described_class) }
end
end
describe '#keyword' do
let(:source) { 'while foo; bar; end' }
it { expect(while_node.keyword).to eq('while') }
end
describe '#inverse_keyword' do
let(:source) { 'while foo; bar; end' }
it { expect(while_node.inverse_keyword).to eq('until') }
end
describe '#do?' do
context 'with a do keyword' do
let(:source) { 'while foo do; bar; end' }
it { expect(while_node.do?).to be_truthy }
end
context 'without a do keyword' do
let(:source) { 'while foo; bar; end' }
it { expect(while_node.do?).to be_falsey }
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cli/ 0000775 0000000 0000000 00000000000 13070542236 0020307 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/spec/rubocop/cli/cli_auto_gen_config_spec.rb 0000664 0000000 0000000 00000045504 13070542236 0025633 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'timeout'
describe RuboCop::CLI, :isolated_environment do
include_context 'cli spec behavior'
subject(:cli) { described_class.new }
describe '--auto-gen-config' do
before do
RuboCop::Formatter::DisabledConfigFormatter
.config_to_allow_offenses = {}
end
it 'overwrites an existing todo file' do
create_file('example1.rb', ['x= 0 ',
'#' * 85,
'y ',
'puts x'])
create_file('.rubocop_todo.yml', ['Metrics/LineLength:',
' Enabled: false'])
create_file('.rubocop.yml', ['inherit_from: .rubocop_todo.yml'])
expect(cli.run(['--auto-gen-config'])).to eq(1)
expect(IO.readlines('.rubocop_todo.yml')[8..-1].map(&:chomp))
.to eq(['# Offense count: 1',
'# Configuration parameters: AllowHeredoc, AllowURI, ' \
'URISchemes, IgnoreCopDirectives, IgnoredPatterns.',
'# URISchemes: http, https',
'Metrics/LineLength:',
' Max: 85',
'',
'# Offense count: 1',
'# Cop supports --auto-correct.',
'# Configuration parameters: AllowForAlignment.',
'Style/SpaceAroundOperators:',
' Exclude:',
" - 'example1.rb'",
'',
'# Offense count: 2',
'# Cop supports --auto-correct.',
'Style/TrailingWhitespace:',
' Exclude:',
" - 'example1.rb'"])
# Create new CLI instance to avoid using cached configuration.
new_cli = described_class.new
expect(new_cli.run(['example1.rb'])).to eq(0)
end
it 'honors rubocop:disable comments' do
create_file('example1.rb', ['#' * 81,
'# rubocop:disable LineLength',
'#' * 85,
'y ',
'puts 123456'])
create_file('.rubocop.yml', ['inherit_from: .rubocop_todo.yml'])
expect(cli.run(['--auto-gen-config'])).to eq(1)
expect(IO.readlines('.rubocop_todo.yml')[8..-1].join)
.to eq(['# Offense count: 1',
'# Configuration parameters: AllowHeredoc, AllowURI, ' \
'URISchemes, IgnoreCopDirectives, IgnoredPatterns.',
'# URISchemes: http, https',
'Metrics/LineLength:',
' Max: 81',
'',
'# Offense count: 1',
'# Cop supports --auto-correct.',
'# Configuration parameters: Strict.',
'Style/NumericLiterals:',
' MinDigits: 7',
'',
'# Offense count: 1',
'# Cop supports --auto-correct.',
'Style/TrailingWhitespace:',
' Exclude:',
" - 'example1.rb'",
''].join("\n"))
end
it 'can generate a todo list' do
create_file('example1.rb', ['$x= 0 ',
'#' * 90,
'#' * 85,
'y ',
'puts x'])
create_file('example2.rb', ['# encoding: utf-8',
'',
"\tx = 0",
'puts x',
'',
'class A',
' def a; end',
'end'])
# Make ConfigLoader reload the default configuration so that its
# absolute Exclude paths will point into this example's work directory.
RuboCop::ConfigLoader.default_configuration = nil
expect(cli.run(['--auto-gen-config'])).to eq(1)
expect($stderr.string).to eq('')
expect($stdout.string)
.to include(['Created .rubocop_todo.yml.',
'Run `rubocop --config .rubocop_todo.yml`, or ' \
'add `inherit_from: .rubocop_todo.yml` in a ' \
'.rubocop.yml file.',
''].join("\n"))
expected =
['# This configuration was generated by',
'# `rubocop --auto-gen-config`',
/# on .* using RuboCop version .*/,
'# The point is for the user to remove these configuration records',
'# one by one as the offenses are removed from the code base.',
'# Note that changes in the inspected code, or installation of new',
'# versions of RuboCop, may require this file to be generated ' \
'again.',
'',
'# Offense count: 2',
'# Configuration parameters: AllowHeredoc, AllowURI, URISchemes, '\
'IgnoreCopDirectives, IgnoredPatterns.',
'# URISchemes: http, https',
'Metrics/LineLength:',
' Max: 90',
'',
'# Offense count: 1',
'# Cop supports --auto-correct.',
'Style/CommentIndentation:',
' Exclude:',
" - 'example2.rb'",
'',
'# Offense count: 1',
'Style/Documentation:',
' Exclude:',
" - 'spec/**/*'", # Copied from default configuration
" - 'test/**/*'", # Copied from default configuration
" - 'example2.rb'",
'',
'# Offense count: 1',
'# Configuration parameters: AllowedVariables.',
'Style/GlobalVars:',
' Exclude:',
" - 'example1.rb'",
'',
'# Offense count: 2',
'# Cop supports --auto-correct.',
'# Configuration parameters: EnforcedStyle, SupportedStyles.',
'# SupportedStyles: normal, rails',
'Style/IndentationConsistency:',
' Exclude:',
" - 'example2.rb'",
'',
'# Offense count: 1',
'# Cop supports --auto-correct.',
'Style/InitialIndentation:',
' Exclude:',
" - 'example2.rb'",
'',
'# Offense count: 1',
'# Cop supports --auto-correct.',
'# Configuration parameters: AllowForAlignment.',
'Style/SpaceAroundOperators:',
' Exclude:',
" - 'example1.rb'",
'',
'# Offense count: 1',
'# Cop supports --auto-correct.',
'Style/Tab:',
' Exclude:',
" - 'example2.rb'",
'',
'# Offense count: 2',
'# Cop supports --auto-correct.',
'Style/TrailingWhitespace:',
' Exclude:',
" - 'example1.rb'"]
actual = IO.read('.rubocop_todo.yml').split($RS)
expected.each_with_index do |line, ix|
if line.is_a?(String)
expect(actual[ix]).to eq(line)
else
expect(actual[ix]).to match(line)
end
end
end
it 'can generate Exclude properties with a given limit' do
create_file('example1.rb', ['$x= 0 ',
'#' * 90,
'#' * 85,
'y ',
'puts x'])
create_file('example2.rb', ['# encoding: utf-8',
'',
'#' * 85,
"\tx = 0",
'puts x'])
expect(cli.run(['--auto-gen-config', '--exclude-limit', '1'])).to eq(1)
expected =
['# This configuration was generated by',
'# `rubocop --auto-gen-config --exclude-limit 1`',
/# on .* using RuboCop version .*/,
'# The point is for the user to remove these configuration records',
'# one by one as the offenses are removed from the code base.',
'# Note that changes in the inspected code, or installation of new',
'# versions of RuboCop, may require this file to be generated ' \
'again.',
'',
'# Offense count: 3',
'# Configuration parameters: AllowHeredoc, AllowURI, URISchemes, '\
'IgnoreCopDirectives, IgnoredPatterns.',
'# URISchemes: http, https',
'Metrics/LineLength:',
' Max: 90', # Offense occurs in 2 files, limit is 1, so no Exclude.
'',
'# Offense count: 1',
'# Cop supports --auto-correct.',
'Style/CommentIndentation:',
' Exclude:',
" - 'example2.rb'",
'',
'# Offense count: 1',
'# Configuration parameters: AllowedVariables.',
'Style/GlobalVars:',
' Exclude:',
" - 'example1.rb'",
'',
'# Offense count: 1',
'# Cop supports --auto-correct.',
'# Configuration parameters: EnforcedStyle, SupportedStyles.',
'# SupportedStyles: normal, rails',
'Style/IndentationConsistency:',
' Exclude:',
" - 'example2.rb'",
'',
'# Offense count: 1',
'# Cop supports --auto-correct.',
'Style/InitialIndentation:',
' Exclude:',
" - 'example2.rb'",
'',
'# Offense count: 1',
'# Cop supports --auto-correct.',
'# Configuration parameters: AllowForAlignment.',
'Style/SpaceAroundOperators:',
' Exclude:',
" - 'example1.rb'",
'',
'# Offense count: 1',
'# Cop supports --auto-correct.',
'Style/Tab:',
' Exclude:',
" - 'example2.rb'",
'',
'# Offense count: 2',
'# Cop supports --auto-correct.',
'Style/TrailingWhitespace:',
' Exclude:',
" - 'example1.rb'"]
actual = IO.read('.rubocop_todo.yml').split($RS)
expected.each_with_index do |line, ix|
if line.is_a?(String)
expect(actual[ix]).to eq(line)
else
expect(actual[ix]).to match(line)
end
end
end
it 'does not generate configuration for the Syntax cop' do
create_file('example1.rb', ['# encoding: utf-8',
'',
'x = < ', # Syntax error
'puts x'])
create_file('example2.rb', ['# encoding: utf-8',
'',
"\tx = 0",
'puts x'])
expect(cli.run(['--auto-gen-config'])).to eq(1)
expect($stderr.string).to eq('')
expected =
['# This configuration was generated by',
'# `rubocop --auto-gen-config`',
/# on .* using RuboCop version .*/,
'# The point is for the user to remove these configuration records',
'# one by one as the offenses are removed from the code base.',
'# Note that changes in the inspected code, or installation of new',
'# versions of RuboCop, may require this file to be generated ' \
'again.',
'',
'# Offense count: 1',
'# Cop supports --auto-correct.',
'Style/CommentIndentation:',
' Exclude:',
" - 'example2.rb'",
'',
'# Offense count: 1',
'# Cop supports --auto-correct.',
'# Configuration parameters: EnforcedStyle, SupportedStyles.',
'# SupportedStyles: normal, rails',
'Style/IndentationConsistency:',
' Exclude:',
" - 'example2.rb'",
'',
'# Offense count: 1',
'# Cop supports --auto-correct.',
'Style/InitialIndentation:',
' Exclude:',
" - 'example2.rb'",
'',
'# Offense count: 1',
'# Cop supports --auto-correct.',
'Style/Tab:',
' Exclude:',
" - 'example2.rb'"]
actual = IO.read('.rubocop_todo.yml').split($RS)
expect(actual.length).to eq(expected.length)
expected.each_with_index do |line, ix|
if line.is_a?(String)
expect(actual[ix]).to eq(line)
else
expect(actual[ix]).to match(line)
end
end
end
it 'generates a todo list that removes the reports' do
create_file('example.rb', 'y.gsub!(/abc\/xyz/, x)')
expect(cli.run(%w[--format emacs])).to eq(1)
expect($stdout.string).to eq("#{abs('example.rb')}:1:9: C: Use `%r` " \
"around regular expression.\n")
expect(cli.run(['--auto-gen-config'])).to eq(1)
expected =
['# This configuration was generated by',
'# `rubocop --auto-gen-config`',
/# on .* using RuboCop version .*/,
'# The point is for the user to remove these configuration records',
'# one by one as the offenses are removed from the code base.',
'# Note that changes in the inspected code, or installation of new',
'# versions of RuboCop, may require this file to be generated ' \
'again.',
'',
'# Offense count: 1',
'# Cop supports --auto-correct.',
'# Configuration parameters: EnforcedStyle, SupportedStyles, ' \
'AllowInnerSlashes.',
'# SupportedStyles: slashes, percent_r, mixed',
'Style/RegexpLiteral:',
' Exclude:',
" - 'example.rb'"]
actual = IO.read('.rubocop_todo.yml').split($RS)
expected.each_with_index do |line, ix|
if line.is_a?(String)
expect(actual[ix]).to eq(line)
else
expect(actual[ix]).to match(line)
end
end
$stdout = StringIO.new
result = cli.run(%w[--config .rubocop_todo.yml --format emacs])
expect($stdout.string).to eq('')
expect(result).to eq(0)
end
it 'does not include offense counts when --no-offense-counts is used' do
create_file('example1.rb', ['$x= 0 ',
'#' * 90,
'#' * 85,
'y ',
'puts x'])
create_file('example2.rb', ['# encoding: utf-8',
'',
"\tx = 0",
'puts x',
'',
'class A',
' def a; end',
'end'])
# Make ConfigLoader reload the default configuration so that its
# absolute Exclude paths will point into this example's work directory.
RuboCop::ConfigLoader.default_configuration = nil
expect(cli.run(['--auto-gen-config', '--no-offense-counts'])).to eq(1)
expect($stderr.string).to eq('')
expect($stdout.string)
.to include(['Created .rubocop_todo.yml.',
'Run `rubocop --config .rubocop_todo.yml`, or ' \
'add `inherit_from: .rubocop_todo.yml` in a ' \
'.rubocop.yml file.',
''].join("\n"))
expected =
['# This configuration was generated by',
'# `rubocop --auto-gen-config --no-offense-counts`',
/# on .* using RuboCop version .*/,
'# The point is for the user to remove these configuration records',
'# one by one as the offenses are removed from the code base.',
'# Note that changes in the inspected code, or installation of new',
'# versions of RuboCop, may require this file to be generated ' \
'again.',
'',
'# Configuration parameters: AllowHeredoc, AllowURI, URISchemes, '\
'IgnoreCopDirectives, IgnoredPatterns.',
'# URISchemes: http, https',
'Metrics/LineLength:',
' Max: 90',
'',
'# Cop supports --auto-correct.',
'Style/CommentIndentation:',
' Exclude:',
" - 'example2.rb'",
'',
'Style/Documentation:',
' Exclude:',
" - 'spec/**/*'", # Copied from default configuration
" - 'test/**/*'", # Copied from default configuration
" - 'example2.rb'",
'',
'# Configuration parameters: AllowedVariables.',
'Style/GlobalVars:',
' Exclude:',
" - 'example1.rb'",
'',
'# Cop supports --auto-correct.',
'# Configuration parameters: EnforcedStyle, SupportedStyles.',
'# SupportedStyles: normal, rails',
'Style/IndentationConsistency:',
' Exclude:',
" - 'example2.rb'",
'',
'# Cop supports --auto-correct.',
'Style/InitialIndentation:',
' Exclude:',
" - 'example2.rb'",
'',
'# Cop supports --auto-correct.',
'# Configuration parameters: AllowForAlignment.',
'Style/SpaceAroundOperators:',
' Exclude:',
" - 'example1.rb'",
'',
'# Cop supports --auto-correct.',
'Style/Tab:',
' Exclude:',
" - 'example2.rb'",
'',
'# Cop supports --auto-correct.',
'Style/TrailingWhitespace:',
' Exclude:',
" - 'example1.rb'"]
actual = IO.read('.rubocop_todo.yml').split($RS)
expected.each_with_index do |line, ix|
if line.is_a?(String)
expect(actual[ix]).to eq(line)
else
expect(actual[ix]).to match(line)
end
end
end
describe 'when different styles appear in different files' do
before do
create_file('example1.rb', ['$!'])
create_file('example2.rb', ['$!'])
create_file('example3.rb', ['$ERROR_INFO'])
end
it 'disables cop if --exclude-limit is exceeded' do
expect(cli.run(['--auto-gen-config', '--exclude-limit', '1'])).to eq(1)
expect(IO.readlines('.rubocop_todo.yml')[8..-1].join)
.to eq(['# Offense count: 2',
'# Cop supports --auto-correct.',
'# Configuration parameters: EnforcedStyle, SupportedStyles.',
'# SupportedStyles: use_perl_names, use_english_names',
'Style/SpecialGlobalVars:',
' Enabled: false',
''].join("\n"))
end
it 'generates Exclude list if --exclude-limit is not exceeded' do
create_file('example4.rb', ['$!'])
expect(cli.run(['--auto-gen-config', '--exclude-limit', '10'])).to eq(1)
expect(IO.readlines('.rubocop_todo.yml')[8..-1].join)
.to eq(['# Offense count: 3',
'# Cop supports --auto-correct.',
'# Configuration parameters: EnforcedStyle, SupportedStyles.',
'# SupportedStyles: use_perl_names, use_english_names',
'Style/SpecialGlobalVars:',
' Exclude:',
" - 'example1.rb'",
" - 'example2.rb'",
" - 'example4.rb'",
''].join("\n"))
end
end
it 'can be called when there are no files to inspection' do
expect(cli.run(['--auto-gen-config'])).to eq(0)
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cli/cli_autocorrect_spec.rb 0000664 0000000 0000000 00000120040 13070542236 0025024 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::CLI, :isolated_environment do
include_context 'cli spec behavior'
subject(:cli) { described_class.new }
before(:each) do
RuboCop::ConfigLoader.default_configuration = nil
end
it 'does not correct ExtraSpacing in a hash that would be changed back' do
create_file('.rubocop.yml', ['Style/AlignHash:',
' EnforcedColonStyle: table'])
source = ['hash = {',
' alice: {',
' age: 23,',
" role: 'Director'",
' },',
' bob: {',
' age: 25,',
" role: 'Consultant'",
' }',
'}']
create_file('example.rb', source)
expect(cli.run(['--auto-correct'])).to eq(1)
expect(IO.read('example.rb')).to eq(source.join("\n") + "\n")
end
it 'does not correct SpaceAroundOperators in a hash that would be ' \
'changed back' do
create_file('.rubocop.yml', ['Style/HashSyntax:',
' EnforcedStyle: hash_rockets',
'',
'Style/AlignHash:',
' EnforcedHashRocketStyle: table'])
source = ['a = { 1=>2, a => b }',
'hash = {',
' :alice => {',
' :age => 23,',
" :role => 'Director'",
' },',
' :bob => {',
' :age => 25,',
" :role => 'Consultant'",
' }',
'}']
create_file('example.rb', source)
expect(cli.run(['--auto-correct'])).to eq(1)
# 1=>2 is changed to 1 => 2. The rest is unchanged.
# SpaceAroundOperators leaves it to AlignHash when the style is table.
expect(IO.read('example.rb')).to eq(['a = { 1 => 2, a => b }',
'hash = {',
' :alice => {',
' :age => 23,',
" :role => 'Director'",
' },',
' :bob => {',
' :age => 25,',
" :role => 'Consultant'",
' }',
'}'].join("\n") + "\n")
end
shared_examples 'trailing comma adder' do |comma_style, brace_configs, corr|
Array(brace_configs).each do |brace_config|
context "with #{comma_style} and #{brace_config} configuration" do
it 'corrects TrailingCommaInLiteral and TrailingCommaInArguments ' \
'without producing a double comma' do
create_file('.rubocop.yml',
['Style/TrailingCommaInArguments:',
" EnforcedStyleForMultiline: #{comma_style}",
'',
'Style/TrailingCommaInLiteral:',
" EnforcedStyleForMultiline: #{comma_style}",
'',
'Style/BracesAroundHashParameters:',
" #{brace_config}"])
source = ['func({',
' @abc => 0,',
' @xyz => 1',
'})',
'func(',
' {',
' abc: 0',
' }',
')',
'func(',
' {},',
' {',
' xyz: 1',
' }',
')']
create_file('example.rb', source)
cli.run(['--auto-correct'])
expect(IO.read('example.rb')).to eq(corr.join("\n") + "\n")
expect($stderr.string).to eq('')
end
end
end
end
it_behaves_like 'trailing comma adder', :comma, ['Enabled: false',
'AutoCorrect: false',
'EnforcedStyle: braces'],
['func({',
' @abc => 0,',
' @xyz => 1,', # comma added
' })',
'func(',
' {',
' abc: 0,', # comma added
' },', # comma added
')',
'func(',
' {},',
' {',
' xyz: 1,', # comma added
' },', # comma added
')']
it_behaves_like 'trailing comma adder', :comma, 'EnforcedStyle: no_braces',
['func(@abc => 0,',
' @xyz => 1)',
'func(',
' abc: 0,', # comma added
')',
'func(',
' {},',
' xyz: 1,', # comma added
')']
it_behaves_like 'trailing comma adder', :comma,
'EnforcedStyle: context_dependent',
['func(@abc => 0,',
' @xyz => 1)',
'func(',
' abc: 0,', # comma added
')',
'func(',
' {},',
' {',
' xyz: 1,', # comma added
' },', # comma added
')']
it_behaves_like 'trailing comma adder', :consistent_comma,
['Enabled: false',
'AutoCorrect: false',
'EnforcedStyle: braces'],
['func({',
' @abc => 0,',
' @xyz => 1,', # comma added
' },)', # comma added
'func(',
' {',
' abc: 0,', # comma added
' },', # comma added
')',
'func(',
' {},',
' {',
' xyz: 1,', # comma added
' },', # comma added
')']
it_behaves_like 'trailing comma adder', :consistent_comma,
'EnforcedStyle: no_braces',
['func(@abc => 0,',
' @xyz => 1,)', # comma added
'func(',
' abc: 0,', # comma added
')',
'func(',
' {},',
' xyz: 1,', # comma added
')']
it_behaves_like 'trailing comma adder', :consistent_comma,
'EnforcedStyle: context_dependent',
['func(@abc => 0,',
' @xyz => 1,)', # comma added
'func(',
' abc: 0,', # comma added
')',
'func(',
' {},',
' {',
' xyz: 1,', # comma added
' },', # comma added
')']
it 'corrects IndentationWidth, RedundantBegin, and ' \
'RescueEnsureAlignment offenses' do
source = ['def verify_section',
' begin',
' scroll_down_until_element_exists',
' rescue',
' scroll_down_until_element_exists',
' end',
'end']
create_file('example.rb', source)
expect(cli.run(['--auto-correct'])).to eq(0)
corrected = ['def verify_section',
' scroll_down_until_element_exists',
'rescue',
' scroll_down_until_element_exists',
'end',
'']
expect(IO.read('example.rb')).to eq(corrected.join("\n"))
end
it 'corrects LineEndConcatenation offenses leaving the ' \
'UnneededInterpolation offense unchanged' do
# If we change string concatenation from plus to backslash, the string
# literal that follows must remain a string literal.
source = ["puts 'foo' +",
' "#{bar}"',
"puts 'a' +",
" 'b'",
'"#{c}"']
create_file('example.rb', source)
expect(cli.run(['--auto-correct'])).to eq(0)
corrected = ["puts 'foo' \\",
' "#{bar}"',
# Expressions that need correction from only one of these cops
# are corrected as expected.
"puts 'a' \\",
" 'b'",
'c.to_s',
'']
expect(IO.read('example.rb')).to eq(corrected.join("\n"))
end
%i[line_count_based semantic braces_for_chaining].each do |style|
context "when BlockDelimiters has #{style} style" do
it 'corrects SpaceBeforeBlockBraces, SpaceInsideBlockBraces offenses' do
source = ['r = foo.map{|a|',
' a.bar.to_s',
'}',
'foo.map{|a|',
' a.bar.to_s',
'}.baz']
create_file('example.rb', source)
create_file('.rubocop.yml', ['Style/BlockDelimiters:',
" EnforcedStyle: #{style}"])
expect(cli.run(['--auto-correct'])).to eq(1)
corrected = case style
when :semantic
['r = foo.map { |a|',
' a.bar.to_s',
'}',
'foo.map { |a|',
' a.bar.to_s',
'}.baz',
'']
when :braces_for_chaining
['r = foo.map do |a|',
' a.bar.to_s',
'end',
'foo.map { |a|',
' a.bar.to_s',
'}.baz',
'']
when :line_count_based
['r = foo.map do |a|',
' a.bar.to_s',
'end',
'foo.map do |a|',
' a.bar.to_s',
'end.baz',
'']
end
expect($stderr.string).to eq('')
expect(IO.read('example.rb')).to eq(corrected.join("\n"))
end
end
end
it 'corrects InitialIndentation offenses' do
source = [' # comment 1',
'',
' # comment 2',
' def func',
' begin',
' foo',
' bar',
' rescue',
' baz',
' end',
' end',
''].join("\n")
create_file('example.rb', source)
create_file('.rubocop.yml', ['Lint/DefEndAlignment:',
' AutoCorrect: true'])
expect(cli.run(['--auto-correct'])).to eq(0)
corrected = ['# comment 1',
'',
'# comment 2',
'def func',
' foo',
' bar',
'rescue',
' baz',
'end',
'']
expect($stderr.string).to eq('')
expect(IO.read('example.rb')).to eq(corrected.join("\n"))
end
it 'corrects UnneededDisable offenses' do
source = ['class A',
' # rubocop:disable Metrics/MethodLength',
' def func',
' x = foo # rubocop:disable Lint/UselessAssignment,Style/For',
' # rubocop:disable all',
' # rubocop:disable Style/ClassVars',
' @@bar = "3"',
' end',
'end',
''].join("\n")
create_file('example.rb', source)
expect(cli.run(%w[--auto-correct --format simple])).to eq(1)
expect($stdout.string)
.to eq(['== example.rb ==',
'C: 1: 1: Missing top-level class documentation comment.',
'W: 2: 3: [Corrected] Unnecessary disabling of ' \
'Metrics/MethodLength.',
'W: 4: 54: [Corrected] Unnecessary disabling of Style/For.',
'W: 6: 5: [Corrected] Unnecessary disabling of ' \
'Style/ClassVars.',
'',
'1 file inspected, 4 offenses detected, 3 offenses corrected',
''].join("\n"))
corrected = ['class A',
' def func',
' x = foo # rubocop:disable Lint/UselessAssignment',
' # rubocop:disable all',
' @@bar = "3"',
' end',
'end',
'']
expect($stderr.string).to eq('')
expect(IO.read('example.rb')).to eq(corrected.join("\n"))
end
it 'corrects RedundantBegin offenses and fixes indentation etc' do
source = [' def func',
' begin',
' foo',
' bar',
' rescue',
' baz',
' end',
' end',
'',
' def func; begin; x; y; rescue; z end end',
'',
'def method',
' begin',
' BlockA do |strategy|',
' foo',
' end',
'',
' BlockB do |portfolio|',
' foo',
' end',
'',
' rescue => e # some problem',
' bar',
' end',
'end',
'',
'def method',
' begin # comment 1',
' do_some_stuff',
' rescue # comment 2',
' end # comment 3',
'end',
''].join("\n")
create_file('example.rb', source)
expect(cli.run(['--auto-correct'])).to eq(1)
corrected = ['def func',
' foo',
' bar',
' rescue',
' baz',
' end',
'',
'def func',
' x; y; rescue; z',
'end',
'',
'def method',
' BlockA do |_strategy|',
' foo',
' end',
'',
' BlockB do |_portfolio|',
' foo',
' end',
'rescue => e # some problem',
' bar',
'end',
'',
'def method',
' # comment 1',
' do_some_stuff',
'rescue # comment 2',
' # comment 3',
'end',
'']
expect(IO.read('example.rb')).to eq(corrected.join("\n"))
end
it 'corrects Tab and IndentationConsistency offenses' do
source = [' render_views',
" describe 'GET index' do",
"\t it 'returns http success' do",
"\t end",
"\tdescribe 'admin user' do",
' before(:each) do',
"\t end",
"\tend",
' end',
'']
create_file('example.rb', source)
expect(cli.run(['--auto-correct'])).to eq(0)
corrected = ['render_views',
"describe 'GET index' do",
" it 'returns http success' do",
' end',
" describe 'admin user' do",
' before(:each) do',
' end',
' end',
'end',
'']
expect(IO.read('example.rb')).to eq(corrected.join("\n"))
end
it 'corrects IndentationWidth and IndentationConsistency offenses' do
source = ["require 'spec_helper'",
'describe ArticlesController do',
' render_views',
' describe "GET \'index\'" do',
' it "returns http success" do',
' end',
' describe "admin user" do',
' before(:each) do',
' end',
' end',
' end',
'end']
create_file('example.rb', source)
expect(cli.run(['--auto-correct'])).to eq(0)
corrected = ["require 'spec_helper'",
'describe ArticlesController do',
' render_views',
" describe \"GET 'index'\" do",
" it 'returns http success' do",
' end',
" describe 'admin user' do",
' before(:each) do',
' end',
' end',
' end',
'end',
'']
expect(IO.read('example.rb')).to eq(corrected.join("\n"))
end
it 'corrects SymbolProc and SpaceBeforeBlockBraces offenses' do
source = ['foo.map{ |a| a.nil? }']
create_file('example.rb', source)
expect(cli.run(['-D', '--auto-correct'])).to eq(0)
corrected = "foo.map(&:nil?)\n"
expect(IO.read('example.rb')).to eq(corrected)
uncorrected = $stdout.string.split($RS).select do |line|
line.include?('example.rb:') && !line.include?('[Corrected]')
end
expect(uncorrected).to be_empty # Hence exit code 0.
end
it 'corrects only IndentationWidth without crashing' do
source = ['foo = if bar',
' something',
'elsif baz',
' other_thing',
'else',
' raise',
'end']
create_file('example.rb', source)
expect(cli.run(%w[--only IndentationWidth --auto-correct])).to eq(0)
corrected = ['foo = if bar',
' something',
'elsif baz',
' other_thing',
'else',
' raise',
'end',
''].join("\n")
expect(IO.read('example.rb')).to eq(corrected)
end
it 'corrects complicated cases conservatively' do
# Two cops make corrections here; Style/BracesAroundHashParameters, and
# Style/AlignHash. Because they make minimal corrections relating only
# to their specific areas, and stay away from cleaning up extra
# whitespace in the process, the combined changes don't interfere with
# each other and the result is semantically the same as the starting
# point.
source = ['expect(subject[:address]).to eq({',
" street1: '1 Market',",
" street2: '#200',",
" city: 'Some Town',",
" state: 'CA',",
" postal_code: '99999-1111'",
'})']
create_file('example.rb', source)
expect(cli.run(['-D', '--auto-correct'])).to eq(0)
corrected =
["expect(subject[:address]).to eq(street1: '1 Market',",
" street2: '#200',",
" city: 'Some Town',",
" state: 'CA',",
" postal_code: '99999-1111')"]
expect(IO.read('example.rb')).to eq(corrected.join("\n") + "\n")
end
it 'honors Exclude settings in individual cops' do
source = 'puts %x(ls)'
create_file('example.rb', source)
create_file('.rubocop.yml', ['Style/CommandLiteral:',
' Exclude:',
' - example.rb'])
expect(cli.run(['--auto-correct'])).to eq(0)
expect($stdout.string).to include('no offenses detected')
expect(IO.read('example.rb')).to eq("#{source}\n")
end
it 'corrects code with indentation problems' do
create_file('example.rb', ['module Bar',
'class Goo',
' def something',
' first call',
" do_other 'things'",
' if other > 34',
' more_work',
' end',
' end',
'end',
'end',
'',
'module Foo',
'class Bar',
'',
' stuff = [',
' {',
" some: 'hash',",
' },',
' {',
" another: 'hash',",
" with: 'more'",
' },',
' ]',
'end',
'end'])
expect(cli.run(['--auto-correct'])).to eq(1)
expect(IO.read('example.rb'))
.to eq(['module Bar',
' class Goo',
' def something',
' first call',
" do_other 'things'",
' more_work if other > 34',
' end',
' end',
'end',
'',
'module Foo',
' class Bar',
' stuff = [',
' {',
" some: 'hash'",
' },',
' {',
" another: 'hash',",
" with: 'more'",
' }',
' ]',
' end',
'end',
''].join("\n"))
end
it 'can change block comments and indent them' do
create_file('example.rb', ['module Foo',
'class Bar',
'=begin',
'This is a nice long',
'comment',
'which spans a few lines',
'=end',
' def baz',
' do_something',
' end',
'end',
'end'])
expect(cli.run(['--auto-correct'])).to eq(1)
expect(IO.read('example.rb'))
.to eq(['module Foo',
' class Bar',
' # This is a nice long',
' # comment',
' # which spans a few lines',
' def baz',
' do_something',
' end',
' end',
'end',
''].join("\n"))
end
it 'can correct two problems with blocks' do
# {} should be do..end and space is missing.
create_file('example.rb', ['(1..10).each{ |i|',
' puts i',
'}'])
expect(cli.run(['--auto-correct'])).to eq(0)
expect(IO.read('example.rb'))
.to eq(['(1..10).each do |i|',
' puts i',
'end',
''].join("\n"))
end
it 'can handle spaces when removing braces' do
create_file('example.rb',
["assert_post_status_code 400, 's', {:type => 'bad'}"])
expect(cli.run(%w[--auto-correct --format emacs])).to eq(0)
expect(IO.read('example.rb'))
.to eq(["assert_post_status_code 400, 's', type: 'bad'",
''].join("\n"))
e = abs('example.rb')
expect($stdout.string)
.to eq(["#{e}:1:35: C: [Corrected] Redundant curly braces around " \
'a hash parameter.',
# TODO: Don't report that a problem is corrected when it
# actually went away due to another correction.
"#{e}:1:35: C: [Corrected] Space inside { missing.",
"#{e}:1:36: C: [Corrected] Use the new Ruby 1.9 hash " \
'syntax.',
"#{e}:1:50: C: [Corrected] Space inside } missing.",
''].join("\n"))
end
# A case where two cops, EmptyLinesAroundBody and EmptyLines, try to
# remove the same line in autocorrect.
it 'can correct two empty lines at end of class body' do
create_file('example.rb', ['class Test',
' def f',
' end',
'',
'',
'end'])
expect(cli.run(['--auto-correct'])).to eq(1)
expect($stderr.string).to eq('')
expect(IO.read('example.rb')).to eq(['class Test',
' def f; end',
'end',
''].join("\n"))
end
# A case where WordArray's correction can be clobbered by
# AccessModifierIndentation's correction.
it 'can correct indentation and another thing' do
create_file('example.rb', ['class Dsl',
'private',
' A = ["git", "path",]',
'end'])
expect(cli.run(%w[--auto-correct --format emacs])).to eq(1)
expect(IO.read('example.rb')).to eq(['class Dsl',
' private',
'',
' A = %w[git path].freeze',
'end',
''].join("\n"))
e = abs('example.rb')
expect($stdout.string)
.to eq(["#{e}:1:1: C: Missing top-level class documentation " \
'comment.',
"#{e}:2:1: C: [Corrected] Indent access modifiers like " \
'`private`.',
"#{e}:2:1: C: [Corrected] Keep a blank line after `private`.",
"#{e}:2:3: W: Useless `private` access modifier.",
"#{e}:3:7: C: [Corrected] Freeze mutable objects assigned " \
'to constants.',
"#{e}:3:7: C: [Corrected] Use `%w` or `%W` " \
'for an array of words.',
"#{e}:3:8: C: [Corrected] Prefer single-quoted strings " \
"when you don't need string interpolation or special " \
'symbols.',
"#{e}:3:15: C: [Corrected] Prefer single-quoted strings " \
"when you don't need string interpolation or special " \
'symbols.',
"#{e}:3:21: C: [Corrected] Avoid comma after the last item " \
'of an array.',
"#{e}:4:7: C: [Corrected] Use `%w` or `%W` " \
'for an array of words.',
''].join("\n"))
end
# A case where the same cop could try to correct an offense twice in one
# place.
it 'can correct empty line inside special form of nested modules' do
create_file('example.rb', ['module A module B',
'',
'end end'])
expect(cli.run(['--auto-correct'])).to eq(1)
expect(IO.read('example.rb')).to eq(['module A module B',
'end end',
''].join("\n"))
uncorrected = $stdout.string.split($RS).select do |line|
line.include?('example.rb:') && !line.include?('[Corrected]')
end
expect(uncorrected).not_to be_empty # Hence exit code 1.
end
it 'can correct single line methods' do
create_file('example.rb', ['def func1; do_something end # comment',
'def func2() do_1; do_2; end'])
expect(cli.run(%w[--auto-correct --format offenses])).to eq(0)
expect(IO.read('example.rb')).to eq(['# comment',
'def func1',
' do_something',
'end',
'',
'def func2',
' do_1',
' do_2',
'end',
''].join("\n"))
expect($stdout.string).to eq(['',
'6 Style/TrailingWhitespace',
'3 Style/Semicolon',
'2 Style/SingleLineMethods',
'1 Style/DefWithParentheses',
'1 Style/EmptyLineBetweenDefs',
'--',
'13 Total',
'',
''].join("\n"))
end
# In this example, the auto-correction (changing "fail" to "raise")
# creates a new problem (alignment of parameters), which is also
# corrected automatically.
it 'can correct a problems and the problem it creates' do
create_file('example.rb',
['fail NotImplementedError,',
" 'Method should be overridden in child classes'"])
expect(cli.run(['--auto-correct'])).to eq(0)
expect(IO.read('example.rb'))
.to eq(['raise NotImplementedError,',
" 'Method should be overridden in child classes'",
''].join("\n"))
expect($stdout.string)
.to eq(['Inspecting 1 file',
'C',
'',
'Offenses:',
'',
'example.rb:1:1: C: [Corrected] Always use raise ' \
'to signal exceptions.',
'fail NotImplementedError,',
'^^^^',
'example.rb:2:6: C: [Corrected] Align the parameters of a ' \
'method call if they span more than one line.',
" 'Method should be overridden in child classes'",
' ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^',
'',
'1 file inspected, 2 offenses detected, 2 offenses ' \
'corrected',
''].join("\n"))
end
# Thanks to repeated auto-correction, we can get rid of the trailing
# spaces, and then the extra empty line.
it 'can correct two problems in the same place' do
create_file('example.rb',
['# Example class.',
'class Klass',
' ',
' def f; end',
'end'])
expect(cli.run(['--auto-correct'])).to eq(0)
expect(IO.read('example.rb'))
.to eq(['# Example class.',
'class Klass',
' def f; end',
'end',
''].join("\n"))
expect($stderr.string).to eq('')
expect($stdout.string)
.to eq(['Inspecting 1 file',
'C',
'',
'Offenses:',
'',
'example.rb:3:1: C: [Corrected] Extra empty line detected ' \
'at class body beginning.',
'example.rb:3:1: C: [Corrected] Trailing whitespace ' \
'detected.',
'',
'1 file inspected, 2 offenses detected, 2 offenses ' \
'corrected',
''].join("\n"))
end
it 'can correct MethodDefParentheses and other offense' do
create_file('example.rb',
['def primes limit',
' 1.upto(limit).select { |i| i.even? }',
'end'])
expect(cli.run(%w[-D --auto-correct])).to eq(0)
expect($stderr.string).to eq('')
expect(IO.read('example.rb'))
.to eq(['def primes(limit)',
' 1.upto(limit).select(&:even?)',
'end',
''].join("\n"))
expect($stdout.string)
.to eq(['Inspecting 1 file',
'C',
'',
'Offenses:',
'',
'example.rb:1:12: C: [Corrected] ' \
'Style/MethodDefParentheses: ' \
'Use def with parentheses when there are parameters.',
'def primes limit',
' ^^^^^',
'example.rb:2:24: C: [Corrected] Style/SymbolProc: ' \
'Pass &:even? as an argument to select instead of a block.',
' 1.upto(limit).select { |i| i.even? }',
' ^^^^^^^^^^^^^^^',
'',
'1 file inspected, 2 offenses detected, 2 offenses ' \
'corrected',
''].join("\n"))
end
it 'can correct WordArray and SpaceAfterComma offenses' do
create_file('example.rb',
["f(type: ['offline','offline_payment'],",
" bar_colors: ['958c12','953579','ff5800','0085cc'])"])
expect(cli.run(%w[-D --auto-correct --format o])).to eq(0)
expect($stdout.string)
.to eq(['',
'4 Style/SpaceAfterComma',
'2 Style/WordArray',
'--',
'6 Total',
'',
''].join("\n"))
expect(IO.read('example.rb'))
.to eq(['f(type: %w[offline offline_payment],',
' bar_colors: %w[958c12 953579 ff5800 0085cc])',
''].join("\n"))
end
it 'can correct SpaceAfterComma and HashSyntax offenses' do
create_file('example.rb',
"I18n.t('description',:property_name => property.name)")
expect(cli.run(%w[-D --auto-correct --format emacs])).to eq(0)
expect($stdout.string)
.to eq(["#{abs('example.rb')}:1:21: C: [Corrected] " \
'Style/SpaceAfterComma: Space missing after comma.',
"#{abs('example.rb')}:1:22: C: [Corrected] " \
'Style/HashSyntax: Use the new Ruby 1.9 hash syntax.',
''].join("\n"))
expect(IO.read('example.rb'))
.to eq("I18n.t('description', property_name: property.name)\n")
end
it 'can correct HashSyntax and SpaceAroundOperators offenses' do
create_file('example.rb', '{ :b=>1 }')
expect(cli.run(%w[-D --auto-correct --format emacs])).to eq(0)
expect(IO.read('example.rb')).to eq("{ b: 1 }\n")
expect($stdout.string)
.to eq(["#{abs('example.rb')}:1:3: C: [Corrected] " \
'Style/HashSyntax: Use the new Ruby 1.9 hash syntax.',
"#{abs('example.rb')}:1:5: C: [Corrected] " \
'Style/SpaceAroundOperators: Surrounding space missing for ' \
'operator `=>`.',
''].join("\n"))
end
it 'can correct HashSyntax when --only is used' do
create_file('example.rb', '{ :b=>1 }')
expect(cli.run(%w[--auto-correct -f emacs
--only Style/HashSyntax])).to eq(0)
expect($stderr.string).to eq('')
expect(IO.read('example.rb')).to eq("{ b: 1 }\n")
expect($stdout.string)
.to eq(["#{abs('example.rb')}:1:3: C: [Corrected] Use the new " \
'Ruby 1.9 hash syntax.',
''].join("\n"))
end
it 'can correct TrailingBlankLines and TrailingWhitespace offenses' do
create_file('example.rb',
['# encoding: utf-8',
'',
' ',
'',
''])
expect(cli.run(%w[--auto-correct --format emacs])).to eq(0)
expect(IO.read('example.rb')).to eq(['# encoding: utf-8',
''].join("\n"))
expect($stdout.string)
.to eq(["#{abs('example.rb')}:2:1: C: [Corrected] 3 trailing " \
'blank lines detected.',
"#{abs('example.rb')}:3:1: C: [Corrected] Trailing " \
'whitespace detected.',
''].join("\n"))
end
it 'can correct MethodCallWithoutArgsParentheses and EmptyLiteral offenses' do
create_file('example.rb', 'Hash.new()')
expect(cli.run(%w[--auto-correct --format emacs])).to eq(0)
expect($stderr.string).to eq('')
expect(IO.read('example.rb')).to eq("{}\n")
expect($stdout.string)
.to eq(["#{abs('example.rb')}:1:1: C: [Corrected] Use hash " \
'literal `{}` instead of `Hash.new`.',
"#{abs('example.rb')}:1:9: C: [Corrected] Do not use " \
'parentheses for method calls with no arguments.',
''].join("\n"))
end
it 'can correct IndentHash offenses with separator style' do
create_file('example.rb',
['CONVERSION_CORRESPONDENCE = {',
' match_for_should: :match,',
' match_for_should_not: :match_when_negated,',
' failure_message_for_should: :failure_message,',
'failure_message_for_should_not: :failure_message_when',
'}'])
create_file('.rubocop.yml',
['Style/AlignHash:',
' EnforcedColonStyle: separator'])
expect(cli.run(%w[--auto-correct])).to eq(0)
expect(IO.read('example.rb'))
.to eq(['CONVERSION_CORRESPONDENCE = {',
' match_for_should: :match,',
' match_for_should_not: :match_when_negated,',
' failure_message_for_should: :failure_message,',
' failure_message_for_should_not: :failure_message_when',
'}.freeze',
''].join("\n"))
end
it 'does not say [Corrected] if correction was avoided' do
src = ['func a do b end',
"Signal.trap('TERM') { system(cmd); exit }",
'def self.some_method(foo, bar: 1)',
' log.debug(foo)',
'end']
corrected = ['func a do b end',
"Signal.trap('TERM') { system(cmd); exit }",
'def self.some_method(foo, bar: 1)',
' log.debug(foo)',
'end']
offenses =
['== example.rb ==',
'C: 1: 8: Prefer {...} over do...end for single-line blocks.',
'C: 2: 34: Do not use semicolons to terminate expressions.',
'W: 3: 27: Unused method argument - bar.']
summary = '1 file inspected, 3 offenses detected'
create_file('.rubocop.yml', ['AllCops:',
' TargetRubyVersion: 2.1'])
create_file('example.rb', src)
expect(cli.run(%w[-a -f simple])).to eq(1)
expect($stderr.string).to eq('')
expect(IO.read('example.rb')).to eq(corrected.join("\n") + "\n")
expect($stdout.string)
.to eq((offenses + ['', summary, '']).join("\n"))
end
it 'does not hang SpaceAfterPunctuation and SpaceInsideParens' do
create_file('example.rb', 'some_method(a, )')
Timeout.timeout(10) do
expect(cli.run(%w[--auto-correct])).to eq(0)
end
expect($stderr.string).to eq('')
expect(IO.read('example.rb')).to eq("some_method(a)\n")
end
it 'does not hang SpaceAfterPunctuation and SpaceInsideBrackets' do
create_file('example.rb', 'puts [1, ]')
Timeout.timeout(10) do
expect(cli.run(%w[--auto-correct])).to eq(0)
end
expect($stderr.string).to eq('')
expect(IO.read('example.rb')).to eq("puts [1]\n")
end
it 'can be disabled for any cop in configuration' do
create_file('example.rb', 'puts "Hello", 123456')
create_file('.rubocop.yml', ['Style/StringLiterals:',
' AutoCorrect: false'])
expect(cli.run(%w[--auto-correct])).to eq(1)
expect($stderr.string).to eq('')
expect(IO.read('example.rb')).to eq("puts \"Hello\", 123_456\n")
end
it 'handles different SpaceInsideBlockBraces and ' \
'SpaceInsideHashLiteralBraces' do
create_file('example.rb', ['{foo: bar,',
' bar: baz,}',
'foo.each {bar;}'])
create_file('.rubocop.yml', [
'Style/SpaceInsideBlockBraces:',
' EnforcedStyle: space',
'Style/SpaceInsideHashLiteralBraces:',
' EnforcedStyle: no_space',
'Style/TrailingCommaInLiteral:',
' EnforcedStyleForMultiline: consistent_comma'
])
expect(cli.run(%w[--auto-correct])).to eq(1)
expect($stderr.string).to eq('')
expect(IO.read('example.rb')).to eq(['{foo: bar,',
' bar: baz,}',
'foo.each { bar; }',
''].join("\n"))
end
it 'corrects BracesAroundHashParameters offenses leaving the ' \
'MultilineHashBraceLayout offense unchanged' do
create_file('example.rb', ['def method_a',
' do_something({ a: 1,',
' })',
'end',
''])
expect($stderr.string).to eq('')
expect(cli.run(%w[--auto-correct])).to eq(0)
expect(IO.read('example.rb')).to eq(['def method_a',
' do_something(a: 1)',
'end',
''].join("\n"))
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cli/cli_options_spec.rb 0000664 0000000 0000000 00000122232 13070542236 0024172 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::CLI, :isolated_environment do
include_context 'cli spec behavior'
subject(:cli) { described_class.new }
before(:each) do
RuboCop::ConfigLoader.default_configuration = nil
end
describe '--list-target-files' do
context 'when there are no files' do
it 'prints nothing with -L' do
cli.run ['-L']
expect($stdout.string).to be_empty
end
it 'prints nothing with --list-target-files' do
cli.run ['--list-target-files']
expect($stdout.string).to be_empty
end
end
context 'when there are some files' do
before do
create_file('show.rabl2', 'object @user => :person')
create_file('show.rabl', 'object @user => :person')
create_file('app.rb', 'puts "hello world"')
create_file('Gemfile', ['source "https://rubygems.org"',
'gem "rubocop"'])
create_file('lib/helper.rb', 'puts "helpful"')
end
context 'when there are no includes or excludes' do
it 'prints known ruby files' do
cli.run ['-L']
expect($stdout.string.split("\n")).to contain_exactly(
'app.rb', 'Gemfile', 'lib/helper.rb', 'show.rabl'
)
end
end
context 'when there is an include and exclude' do
before do
create_file('.rubocop.yml', ['AllCops:',
' Exclude:',
' - Gemfile',
' Include:',
' - "**/*.rabl2"'])
end
it 'prints the included files and not the excluded ones' do
cli.run ['--list-target-files']
expect($stdout.string.split("\n")).to contain_exactly(
'app.rb', 'lib/helper.rb', 'show.rabl', 'show.rabl2'
)
end
end
end
end
describe '--version' do
it 'exits cleanly' do
expect(cli.run(['-v'])).to eq(0)
expect(cli.run(['--version'])).to eq(0)
expect($stdout.string).to eq((RuboCop::Version::STRING + "\n") * 2)
end
end
describe '--only' do
context 'when one cop is given' do
it 'runs just one cop' do
# The disable comment should not be reported as unnecessary (even if
# it is) since --only overrides configuration.
create_file('example.rb', ['# rubocop:disable LineLength',
'if x== 0 ',
"\ty",
'end'])
# IfUnlessModifier depends on the configuration of LineLength.
expect(cli.run(['--format', 'simple',
'--only', 'Style/IfUnlessModifier',
'example.rb'])).to eq(1)
expect($stdout.string)
.to eq(['== example.rb ==',
'C: 2: 1: Favor modifier if usage when ' \
'having a single-line body. Another good alternative is ' \
'the usage of control flow &&/||.',
'',
'1 file inspected, 1 offense detected',
''].join("\n"))
end
it 'exits with error if an incorrect cop name is passed' do
create_file('example.rb', ['if x== 0 ',
"\ty",
'end'])
expect(cli.run(['--only', 'Style/123'])).to eq(2)
expect($stderr.string)
.to include('Unrecognized cop or department: Style/123.')
end
it 'exits with error if an empty string is given' do
create_file('example.rb', 'x')
expect(cli.run(['--only', ''])).to eq(2)
expect($stderr.string).to include('Unrecognized cop or department: .')
end
%w[Syntax Lint/Syntax].each do |name|
it "only checks syntax if #{name} is given" do
create_file('example.rb', 'x ')
expect(cli.run(['--only', name])).to eq(0)
expect($stdout.string).to include('no offenses detected')
end
end
%w[Lint/UnneededDisable UnneededDisable].each do |name|
it "exits with error if cop name #{name} is passed" do
create_file('example.rb', ['if x== 0 ',
"\ty",
'end'])
expect(cli.run(['--only', 'UnneededDisable'])).to eq(2)
expect($stderr.string)
.to include('Lint/UnneededDisable can not be used with --only.')
end
end
it 'accepts cop names from plugins' do
create_file('.rubocop.yml', ['require: rubocop_ext',
'',
'Style/SomeCop:',
' Description: Something',
' Enabled: true'])
create_file('rubocop_ext.rb', ['module RuboCop',
' module Cop',
' module Style',
' class SomeCop < Cop',
' end',
' end',
' end',
'end'])
create_file('redirect.rb', '$stderr = STDOUT')
rubocop = "#{RuboCop::ConfigLoader::RUBOCOP_HOME}/bin/rubocop"
# Since we define a new cop class, we have to do this in a separate
# process. Otherwise, the extra cop will affect other specs.
output =
`ruby -I . "#{rubocop}" --require redirect.rb --only Style/SomeCop`
expect($CHILD_STATUS.success?).to be_truthy
expect(output)
.to eq(['Inspecting 2 files',
'..',
'',
'2 files inspected, no offenses detected',
''].join("\n"))
end
context 'without using namespace' do
it 'runs just one cop' do
create_file('example.rb', ['if x== 0 ',
"\ty",
'end'])
expect(cli.run(['--format', 'simple',
'--display-cop-names',
'--only', 'IfUnlessModifier',
'example.rb'])).to eq(1)
expect($stdout.string)
.to eq(['== example.rb ==',
'C: 1: 1: Style/IfUnlessModifier: Favor modifier if ' \
'usage when having a single-line body. Another good ' \
'alternative is the usage of control flow &&/||.',
'',
'1 file inspected, 1 offense detected',
''].join("\n"))
end
end
it 'enables the given cop' do
create_file('example.rb',
['x = 0 ',
# Disabling comments still apply.
'# rubocop:disable Style/TrailingWhitespace',
'y = 1 '])
create_file('.rubocop.yml', ['Style/TrailingWhitespace:',
' Enabled: false'])
expect(cli.run(['--format', 'simple',
'--only', 'Style/TrailingWhitespace',
'example.rb'])).to eq(1)
expect($stderr.string).to eq('')
expect($stdout.string)
.to eq(['== example.rb ==',
'C: 1: 6: Trailing whitespace detected.',
'',
'1 file inspected, 1 offense detected',
''].join("\n"))
end
end
context 'when several cops are given' do
it 'runs the given cops' do
create_file('example.rb', ['if x== 100000000000000 ',
"\ty",
'end'])
expect(cli.run(['--format', 'simple',
'--only',
'Style/IfUnlessModifier,Style/Tab,' \
'Style/SpaceAroundOperators',
'example.rb'])).to eq(1)
expect($stderr.string).to eq('')
expect($stdout.string)
.to eq(['== example.rb ==',
'C: 1: 1: Favor modifier if usage when ' \
'having a single-line body. Another good alternative is ' \
'the usage of control flow &&/||.',
'C: 1: 5: Surrounding space missing for operator ==.',
'C: 2: 1: Tab detected.',
'',
'1 file inspected, 3 offenses detected',
''].join("\n"))
end
context 'and --lint' do
it 'runs the given cops plus all enabled lint cops' do
create_file('example.rb', ['if x== 100000000000000 ',
"\ty = 3",
' end'])
create_file('.rubocop.yml', ['Lint/EndAlignment:',
' Enabled: false'])
expect(cli.run(['--format', 'simple',
'--only', 'Style/Tab,Style/SpaceAroundOperators',
'--lint',
'example.rb'])).to eq(1)
expect($stdout.string)
.to eq(['== example.rb ==',
'C: 1: 5: Surrounding space missing for operator ==.',
'C: 2: 1: Tab detected.',
'W: 2: 2: Useless assignment to variable - y.',
'',
'1 file inspected, 3 offenses detected',
''].join("\n"))
end
end
end
context 'when a namespace is given' do
it 'runs all enabled cops in that namespace' do
create_file('example.rb', ['if x== 100000000000000 ',
' ' + '#' * 100,
"\ty",
'end'])
expect(cli.run(%w[-f offenses --only Metrics example.rb])).to eq(1)
expect($stdout.string).to eq(['',
'1 Metrics/LineLength',
'--',
'1 Total',
'',
''].join("\n"))
end
end
context 'when two namespaces are given' do
it 'runs all enabled cops in those namespaces' do
create_file('example.rb', ['if x== 100000000000000 ',
' # ' + '-' * 98,
"\ty",
'end'])
create_file('.rubocop.yml', ['Style/SpaceAroundOperators:',
' Enabled: false'])
expect(cli.run(%w[-f o --only Metrics,Style example.rb])).to eq(1)
expect($stdout.string)
.to eq(['',
'1 Metrics/LineLength',
'1 Style/CommentIndentation',
'1 Style/IndentationWidth',
'1 Style/NumericLiterals',
'1 Style/Tab',
'1 Style/TrailingWhitespace',
'--',
'6 Total',
'',
''].join("\n"))
end
end
end
describe '--except' do
context 'when one name is given' do
it 'exits with error if the cop name is incorrect' do
create_file('example.rb', ['if x== 0 ',
"\ty",
'end'])
expect(cli.run(['--except', 'Style/123'])).to eq(2)
expect($stderr.string)
.to include('Unrecognized cop or department: Style/123.')
end
it 'exits with error if an empty string is given' do
create_file('example.rb', 'x')
expect(cli.run(['--except', ''])).to eq(2)
expect($stderr.string).to include('Unrecognized cop or department: .')
end
%w[Syntax Lint/Syntax].each do |name|
it "exits with error if #{name} is given" do
create_file('example.rb', 'x ')
expect(cli.run(['--except', name])).to eq(2)
expect($stderr.string)
.to include('Syntax checking can not be turned off.')
end
end
end
context 'when one cop plus one namespace are given' do
it 'runs all cops except the given' do
# The disable comment should not be reported as unnecessary (even if
# it is) since --except overrides configuration.
create_file('example.rb', ['# rubocop:disable LineLength',
'if x== 0 ',
"\ty = 3",
'end'])
expect(cli.run(['--format', 'offenses',
'--except', 'Style/IfUnlessModifier,Lint',
'example.rb'])).to eq(1)
expect($stdout.string)
.to eq(['',
# Note: No Lint/UselessAssignment offense.
'1 Style/IndentationWidth',
'1 Style/NumericPredicate',
'1 Style/SpaceAroundOperators',
'1 Style/Tab',
'1 Style/TrailingWhitespace',
'--',
'5 Total',
'',
''].join("\n"))
end
end
context 'when one cop is given without namespace' do
it 'disables the given cop' do
create_file('example.rb', ['if x== 0 ',
"\ty",
'end'])
cli.run(['--format', 'offenses',
'--except', 'IfUnlessModifier',
'example.rb'])
with_option = $stdout.string
$stdout = StringIO.new
cli.run(['--format', 'offenses',
'example.rb'])
without_option = $stdout.string
expect(without_option.split($RS) - with_option.split($RS))
.to eq(['1 Style/IfUnlessModifier', '6 Total'])
end
end
context 'when several cops are given' do
%w[UnneededDisable Lint/UnneededDisable Lint].each do |cop_name|
it "disables the given cops including #{cop_name}" do
create_file('example.rb', ['if x== 100000000000000 ',
"\ty",
'end # rubocop:disable all'])
expect(cli.run(['--format', 'offenses',
'--except',
'Style/IfUnlessModifier,Style/Tab,' \
"Style/SpaceAroundOperators,#{cop_name}",
'example.rb'])).to eq(1)
expect($stderr.string).to eq('')
expect($stdout.string)
.to eq(['',
'1 Style/IndentationWidth',
'1 Style/NumericLiterals',
'1 Style/TrailingWhitespace',
'--',
'3 Total',
'',
''].join("\n"))
end
end
end
end
describe '--lint' do
it 'runs only lint cops' do
create_file('example.rb', ['if 0 ',
"\ty",
"\tz # rubocop:disable Style/Tab",
'end'])
# IfUnlessModifier depends on the configuration of LineLength.
expect(cli.run(['--format', 'simple', '--lint',
'example.rb'])).to eq(1)
expect($stdout.string)
.to eq(['== example.rb ==',
'W: 1: 4: Literal 0 appeared in a condition.',
'',
'1 file inspected, 1 offense detected',
''].join("\n"))
end
end
describe '-d/--debug' do
it 'shows config files' do
create_file('example1.rb', "\tputs 0")
expect(cli.run(['--debug', 'example1.rb'])).to eq(1)
home = File.dirname(File.dirname(File.dirname(File.dirname(__FILE__))))
expect($stdout.string.lines.grep(/configuration/).map(&:chomp))
.to eq(["For #{abs('')}:" \
" configuration from #{home}/config/default.yml",
"Inheriting configuration from #{home}/config/enabled.yml",
"Inheriting configuration from #{home}/config/disabled.yml"])
end
it 'shows cop names' do
create_file('example1.rb', 'puts 0 ')
file = abs('example1.rb')
expect(cli.run(['--format',
'emacs',
'--debug',
'example1.rb'])).to eq(1)
expect($stdout.string.lines.to_a[-1])
.to eq("#{file}:1:7: C: Style/TrailingWhitespace: Trailing " \
"whitespace detected.\n")
end
end
describe '-D/--display-cop-names' do
it 'shows cop names' do
create_file('example1.rb', 'puts 0 # rubocop:disable NumericLiterals ')
file = abs('example1.rb')
expect(cli.run(['--format', 'emacs', '--display-cop-names',
'example1.rb'])).to eq(1)
expect($stdout.string)
.to eq(["#{file}:1:8: W: Lint/UnneededDisable: Unnecessary " \
'disabling of `Style/NumericLiterals`.',
"#{file}:1:41: C: Style/TrailingWhitespace: Trailing " \
'whitespace detected.',
''].join("\n"))
end
end
describe '-E/--extra-details' do
it 'shows extra details' do
create_file('example1.rb', 'puts 0 # rubocop:disable NumericLiterals ')
create_file('.rubocop.yml',
['TrailingWhitespace:',
' Details: Trailing space is just sloppy.'])
file = abs('example1.rb')
expect(cli.run(['--format', 'emacs', '--extra-details',
'example1.rb'])).to eq(1)
expect($stdout.string)
.to eq(["#{file}:1:8: W: Unnecessary disabling of " \
'`Style/NumericLiterals`. ',
"#{file}:1:41: C: Trailing " \
'whitespace detected. Trailing space is just sloppy.',
''].join("\n"))
expect($stderr.string).to eq('')
end
end
describe '-S/--display-style-guide' do
it 'shows style guide entry' do
create_file('example1.rb', 'puts 0 ')
file = abs('example1.rb')
url =
'https://github.com/bbatsov/ruby-style-guide#no-trailing-whitespace'
expect(cli.run(['--format',
'emacs',
'--display-style-guide',
'example1.rb'])).to eq(1)
expect($stdout.string.lines.to_a[-1])
.to eq("#{file}:1:7: C: Trailing whitespace detected. (#{url})\n")
end
it 'shows reference entry' do
create_file('example1.rb', '[1, 2, 3].reverse.each { |e| puts e }')
file = abs('example1.rb')
url = 'https://github.com/JuanitoFatas/fast-ruby' \
'#enumerablereverseeach-vs-enumerablereverse_each-code'
expect(cli.run(['--format',
'emacs',
'--display-style-guide',
'example1.rb'])).to eq(1)
output = "#{file}:1:11: C: " \
"Use `reverse_each` instead of `reverse.each`. (#{url})"
expect($stdout.string.lines.to_a[-1])
.to eq([output, ''].join("\n"))
end
it 'shows style guide and reference entries' do
create_file('example1.rb', '$foo = 1')
file = abs('example1.rb')
style_guide_link = 'https://github.com/bbatsov/ruby-style-guide' \
'#instance-vars'
reference_link = 'http://www.zenspider.com/Languages/Ruby/QuickRef.html'
expect(cli.run(['--format',
'emacs',
'--display-style-guide',
'example1.rb'])).to eq(1)
output = "#{file}:1:1: C: " \
'Do not introduce global variables. ' \
"(#{style_guide_link}, #{reference_link})"
expect($stdout.string.lines.to_a[-1])
.to eq([output, ''].join("\n"))
end
end
describe '--show-cops' do
shared_examples(:prints_config) do
it 'prints the current configuration' do
out = stdout.lines.to_a
printed_config = YAML.load(out.join) # rubocop:disable Security/YAMLLoad
cop_names = (cop_list[0] || '').split(',')
cop_names.each do |cop_name|
global_conf[cop_name].each do |key, value|
printed_value = printed_config[cop_name][key]
expect(printed_value).to eq(value)
end
end
end
end
let(:cops) { RuboCop::Cop::Cop.all }
let(:registry) { RuboCop::Cop::Cop.registry }
let(:global_conf) do
config_path =
RuboCop::ConfigLoader.configuration_file_for(Dir.pwd.to_s)
RuboCop::ConfigLoader.configuration_from_file(config_path)
end
let(:stdout) { $stdout.string }
before do
create_file('.rubocop.yml', ['Metrics/LineLength:',
' Max: 110'])
# expect(cli.run(['--show-cops'] + cop_list)).to eq(0)
cli.run(['--show-cops'] + cop_list)
end
context 'with no args' do
let(:cop_list) { [] }
# Extracts the first line out of the description
def short_description_of_cop(cop)
desc = full_description_of_cop(cop)
desc ? desc.lines.first.strip : ''
end
# Gets the full description of the cop or nil if no description is set.
def full_description_of_cop(cop)
cop_config = global_conf.for_cop(cop)
cop_config['Description']
end
it 'prints all available cops and their description' do
cops.each do |cop|
expect(stdout).to include cop.cop_name
# Because of line breaks, we will only find the beginning.
expect(stdout).to include short_description_of_cop(cop)[0..60]
end
end
it 'prints all departments' do
registry.departments.each do |department|
expect(stdout).to include(department.to_s)
end
end
it 'prints all cops in their right department listing' do
lines = stdout.lines
lines.slice_before(/Department /).each do |slice|
departments = registry.departments.map(&:to_s)
current =
departments.delete(slice.shift[/Department '(?[^']+)'/, 'c'])
# all cops in their department listing
registry.with_department(current).each do |cop|
expect(slice.any? { |l| l.include? cop.cop_name }).to be_truthy
end
# no cop in wrong department listing
departments.each do |department|
registry.with_department(department).each do |cop|
expect(slice.any? { |l| l.include? cop.cop_name }).to be_falsey
end
end
end
end
include_examples :prints_config
end
context 'with one cop given' do
let(:cop_list) { ['Style/Tab'] }
it 'prints that cop and nothing else' do
expect(stdout).to match(
['# Supports --auto-correct',
'Style/Tab:',
' Description: No hard tabs.',
/^ StyleGuide: ('|")#spaces-indentation('|")$/,
' Enabled: true',
'',
''].join("\n")
)
end
include_examples :prints_config
end
context 'with two cops given' do
let(:cop_list) { ['Style/Tab,Metrics/LineLength'] }
include_examples :prints_config
end
context 'with one of the cops misspelled' do
let(:cop_list) { ['Style/Tab,Lint/X123'] }
it 'skips the unknown cop' do
expect(stdout).to match(
['# Supports --auto-correct',
'Style/Tab:',
' Description: No hard tabs.',
/^ StyleGuide: ('|")#spaces-indentation('|")$/,
' Enabled: true',
'',
''].join("\n")
)
end
end
end
describe '-f/--format' do
let(:target_file) { 'example.rb' }
before do
create_file(target_file, '#' * 90)
end
describe 'builtin formatters' do
context 'when simple format is specified' do
it 'outputs with simple format' do
cli.run(['--format', 'simple', 'example.rb'])
expect($stdout.string)
.to include(["== #{target_file} ==",
'C: 1: 81: Line is too long. [90/80]'].join("\n"))
end
end
%w[html json].each do |format|
context "when #{format} format is specified" do
context 'and offenses come from the cache' do
context 'and a message has binary encoding' do
let(:message_from_cache) do
'Cyclomatic complexity for 文 is too high. [8/6]'
.dup
.force_encoding('ASCII-8BIT')
end
let(:data_from_cache) do
[
{
'severity' => 'convention',
'location' => { 'begin_pos' => 18, 'end_pos' => 21 },
'message' => message_from_cache,
'cop_name' => 'Metrics/CyclomaticComplexity',
'status' => 'unsupported'
}
]
end
it "outputs #{format.upcase} code without crashing" do
create_file('example.rb', ['def 文',
' b if a',
' b if a',
' b if a',
' b if a',
' b if a',
' b if a',
' b if a',
'end'])
# Stub out the JSON.load call used by the cache mechanism, so
# we can test what happens when an offense message has
# ASCII-8BIT encoding and contains a non-7bit-ascii character.
allow(JSON).to receive(:load).and_return(data_from_cache)
2.times do
# The second run (and possibly the first) should hit the
# cache.
expect(cli.run(['--format', format,
'--only', 'Metrics/CyclomaticComplexity']))
.to eq(1)
end
expect($stderr.string).to eq('')
end
end
end
end
end
context 'when clang format is specified' do
it 'outputs with clang format' do
create_file('example1.rb', ['x= 0 ',
'#' * 85,
'y ',
'puts x'])
create_file('example2.rb', ['# encoding: utf-8',
'',
"\tx",
'def a',
' puts',
'end'])
create_file('example3.rb', ['def badName',
' if something',
' test',
' end',
'end'])
expect(cli.run(['--format', 'clang', 'example1.rb',
'example2.rb', 'example3.rb']))
.to eq(1)
expect($stdout.string)
.to eq(['example1.rb:1:2: C: Surrounding space missing for ' \
'operator =.',
'x= 0 ',
' ^',
'example1.rb:1:5: C: Trailing whitespace detected.',
'x= 0 ',
' ^',
'example1.rb:2:81: C: Line is too long. [85/80]',
'###################################################' \
'##################################',
' ' \
' ^^^^^',
'example1.rb:3:2: C: Trailing whitespace detected.',
'y ',
' ^',
'example2.rb:1:1: C: Incorrect indentation detected' \
' (column 0 instead of 1).',
'# encoding: utf-8',
'^^^^^^^^^^^^^^^^^',
'example2.rb:3:1: C: Tab detected.',
"\tx",
'^',
'example2.rb:3:2: C: Indentation of first line in file ' \
'detected.',
"\tx",
' ^',
'example2.rb:4:1: C: Inconsistent indentation ' \
'detected.',
'def a ...',
'^^^^^',
'example2.rb:5:1: C: Use 2 (not 3) spaces for ' \
'indentation.',
' puts',
'^^^',
'example3.rb:1:5: C: Use snake_case for method names.',
'def badName',
' ^^^^^^^',
'example3.rb:2:3: C: Use a guard clause instead of ' \
'wrapping the code inside a conditional expression.',
' if something',
' ^^',
'example3.rb:2:3: C: Favor modifier if usage ' \
'when having a single-line body. Another good ' \
'alternative is the usage of control flow &&/||.',
' if something',
' ^^',
'example3.rb:4:5: W: end at 4, 4 is not aligned ' \
'with if at 2, 2.',
' end',
' ^^^',
'',
'3 files inspected, 13 offenses detected',
''].join("\n"))
end
end
context 'when emacs format is specified' do
it 'outputs with emacs format' do
create_file('example1.rb', ['# encoding: utf-8',
'',
'x= 0 ',
'y ',
'puts x'])
create_file('example2.rb', ['# encoding: utf-8',
'',
"\tx = 0",
'puts x'])
expect(cli.run(['--format', 'emacs', 'example1.rb',
'example2.rb'])).to eq(1)
expected_output =
["#{abs('example1.rb')}:3:2: C: Surrounding space missing" \
' for operator `=`.',
"#{abs('example1.rb')}:3:5: C: Trailing whitespace detected.",
"#{abs('example1.rb')}:4:2: C: Trailing whitespace detected.",
"#{abs('example2.rb')}:1:1: C: Incorrect indentation detected" \
' (column 0 instead of 1).',
"#{abs('example2.rb')}:3:1: C: Tab detected.",
"#{abs('example2.rb')}:3:2: C: Indentation of first line in " \
'file detected.',
"#{abs('example2.rb')}:4:1: C: Inconsistent indentation " \
'detected.',
''].join("\n")
expect($stdout.string).to eq(expected_output)
end
end
context 'when unknown format name is specified' do
it 'aborts with error message' do
expect(cli.run(['--format', 'unknown', 'example.rb'])).to eq(2)
expect($stderr.string)
.to include('No formatter for "unknown"')
end
end
context 'when ambiguous format name is specified' do
it 'aborts with error message' do
# Both 'files' and 'fuubar' start with an 'f'.
expect(cli.run(['--format', 'f', 'example.rb'])).to eq(2)
expect($stderr.string)
.to include('Cannot determine formatter for "f"')
end
end
end
describe 'custom formatter' do
let(:target_file) { abs('example.rb') }
context 'when a class name is specified' do
it 'uses the class as a formatter' do
module MyTool
class RuboCopFormatter < RuboCop::Formatter::BaseFormatter
def started(all_files)
output.puts "started: #{all_files.join(',')}"
end
def file_started(file, _options)
output.puts "file_started: #{file}"
end
def file_finished(file, _offenses)
output.puts "file_finished: #{file}"
end
def finished(processed_files)
output.puts "finished: #{processed_files.join(',')}"
end
end
end
cli.run(['--format', 'MyTool::RuboCopFormatter', 'example.rb'])
expect($stdout.string).to eq(["started: #{target_file}",
"file_started: #{target_file}",
"file_finished: #{target_file}",
"finished: #{target_file}",
''].join("\n"))
end
end
context 'when unknown class name is specified' do
it 'aborts with error message' do
args = '--format UnknownFormatter example.rb'
expect(cli.run(args.split)).to eq(2)
expect($stderr.string).to include('UnknownFormatter')
end
end
end
it 'can be used multiple times' do
cli.run(['--format', 'simple', '--format', 'emacs', 'example.rb'])
expect($stdout.string)
.to include(["== #{target_file} ==",
'C: 1: 81: Line is too long. [90/80]',
"#{abs(target_file)}:1:81: C: Line is too long. " \
'[90/80]'].join("\n"))
end
end
describe '-o/--out option' do
let(:target_file) { 'example.rb' }
before do
create_file(target_file, '#' * 90)
end
it 'redirects output to the specified file' do
cli.run(['--out', 'output.txt', target_file])
expect(File.read('output.txt')).to include('Line is too long.')
end
it 'is applied to the previously specified formatter' do
cli.run(['--format', 'simple',
'--format', 'emacs', '--out', 'emacs_output.txt',
target_file])
expect($stdout.string).to eq(["== #{target_file} ==",
'C: 1: 81: Line is too long. [90/80]',
'',
'1 file inspected, 1 offense detected',
''].join("\n"))
expect(File.read('emacs_output.txt'))
.to eq(["#{abs(target_file)}:1:81: C: Line is too long. [90/80]",
''].join("\n"))
end
end
describe '--fail-level option' do
let(:target_file) { 'example.rb' }
before do
create_file(target_file, ['def f',
' x',
'end'])
end
after do
expect($stderr.string).to eq('')
expect($stdout.string)
.to include('1 file inspected, 1 offense detected')
end
it 'fails when option is less than the severity level' do
expect(cli.run(['--fail-level', 'refactor', target_file])).to eq(1)
expect(cli.run(['--fail-level', 'autocorrect', target_file])).to eq(1)
end
it 'fails when option is equal to the severity level' do
expect(cli.run(['--fail-level', 'convention', target_file])).to eq(1)
end
it 'succeeds when option is greater than the severity level' do
expect(cli.run(['--fail-level', 'warning', target_file])).to eq(0)
end
context 'with --auto-correct' do
after do
expect($stdout.string.lines.to_a.last)
.to eq('1 file inspected, 1 offense detected, 1 offense corrected' \
"\n")
end
it 'fails when option is autocorrect and all offenses are ' \
'autocorrected' do
expect(cli.run(['--auto-correct', '--format', 'simple',
'--fail-level', 'autocorrect',
target_file])).to eq(1)
end
it 'fails when option is A and all offenses are autocorrected' do
expect(cli.run(['--auto-correct', '--format', 'simple',
'--fail-level', 'A',
target_file])).to eq(1)
end
it 'succeeds when option is not given and all offenses are ' \
'autocorrected' do
expect(cli.run(['--auto-correct', '--format', 'simple',
target_file])).to eq(0)
end
it 'succeeds when option is refactor and all offenses are ' \
'autocorrected' do
expect(cli.run(['--auto-correct', '--format', 'simple',
'--fail-level', 'refactor',
target_file])).to eq(0)
end
end
end
describe 'with --auto-correct and disabled offense' do
let(:target_file) { 'example.rb' }
after do
expect($stdout.string.lines.to_a.last)
.to eq('1 file inspected, no offenses detected' \
"\n")
end
it 'succeeds when there is only a disabled offense' do
create_file(target_file, ['def f',
' x # rubocop:disable Style/IndentationWidth',
'end'])
expect(cli.run(['--auto-correct', '--format', 'simple',
'--fail-level', 'autocorrect',
target_file])).to eq(0)
end
end
describe '--force-exclusion' do
context 'when explicitely excluded' do
let(:target_file) { 'example.rb' }
before do
create_file(target_file, '#' * 90)
create_file('.rubocop.yml', ['AllCops:',
' Exclude:',
" - #{target_file}"])
end
it 'excludes files specified in the configuration Exclude ' \
'even if they are explicitly passed as arguments' do
expect(cli.run(['--force-exclusion', target_file])).to eq(0)
end
end
context 'with already excluded by default' do
let(:target_file) { 'TODO.md' }
before do
create_file(target_file, '- one')
end
it 'excludes files excluded by default even if they are ' \
'explicitly passed as arguments' do
expect(cli.run(['--force-exclusion', target_file])).to eq(0)
end
end
end
describe '--stdin' do
it 'causes source code to be read from stdin' do
begin
$stdin = StringIO.new('p $/')
argv = ['--only=Style/SpecialGlobalVars',
'--format=simple',
'--stdin',
'fake.rb']
expect(cli.run(argv)).to eq(1)
expect($stdout.string).to eq([
'== fake.rb ==',
'C: 1: 3: Prefer $INPUT_RECORD_SEPARATOR or $RS from the ' \
"stdlib 'English' module (don't forget to require it) over $/.",
'',
'1 file inspected, 1 offense detected',
''
].join("\n"))
ensure
$stdin = STDIN
end
end
it 'requires a file path' do
begin
$stdin = StringIO.new('p $/')
argv = ['--only=Style/SpecialGlobalVars',
'--format=simple',
'--stdin']
expect(cli.run(argv)).to eq(2)
expect($stderr.string).to include('missing argument: --stdin')
ensure
$stdin = STDIN
end
end
it 'does not accept more than one file path' do
begin
$stdin = StringIO.new('p $/')
argv = ['--only=Style/SpecialGlobalVars',
'--format=simple',
'--stdin',
'fake1.rb',
'fake2.rb']
expect(cli.run(argv)).to eq(2)
expect($stderr.string).to include(
'-s/--stdin requires exactly one path.'
)
ensure
$stdin = STDIN
end
end
it 'prints corrected code to stdout if --autocorrect is used' do
begin
$stdin = StringIO.new('p $/')
argv = ['--auto-correct',
'--only=Style/SpecialGlobalVars',
'--format=simple',
'--stdin',
'fake.rb']
expect(cli.run(argv)).to eq(0)
expect($stdout.string).to eq([
'== fake.rb ==',
'C: 1: 3: [Corrected] Prefer $INPUT_RECORD_SEPARATOR or $RS from ' \
"the stdlib 'English' module (don't forget to require it) over $/.",
'',
'1 file inspected, 1 offense detected, 1 offense corrected',
'====================',
'p $INPUT_RECORD_SEPARATOR'
].join("\n"))
ensure
$stdin = STDIN
end
end
it 'detects CR at end of line' do
begin
create_file('example.rb', "puts 'hello world'\r")
# Make Style/EndOfLine give same output regardless of platform.
create_file('.rubocop.yml', ['Style/EndOfLine:',
' EnforcedStyle: lf'])
File.open('example.rb') do |file|
# We must use a File object to simulate the behavior of
# STDIN, which is an IO object. StringIO won't do in this
# case, as its read() method doesn't handle line endings the
# same way IO#read() does.
$stdin = file
argv = ['--only=Style/EndOfLine',
'--format=simple',
'--stdin',
'fake.rb']
expect(cli.run(argv)).to eq(1)
expect($stdout.string)
.to eq(['== fake.rb ==',
'C: 1: 1: Carriage return character detected.',
'',
'1 file inspected, 1 offense detected',
''].join("\n"))
end
ensure
$stdin = STDIN
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cli_spec.rb 0000664 0000000 0000000 00000165303 13070542236 0021656 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'timeout'
describe RuboCop::CLI, :isolated_environment do
include_context 'cli spec behavior'
subject(:cli) { described_class.new }
context 'when interrupted' do
it 'returns 1' do
allow_any_instance_of(RuboCop::Runner)
.to receive(:aborting?).and_return(true)
create_file('example.rb', '# encoding: utf-8')
expect(cli.run(['example.rb'])).to eq(1)
end
end
describe '#trap_interrupt' do
let(:runner) { RuboCop::Runner.new({}, RuboCop::ConfigStore.new) }
let(:interrupt_handlers) { [] }
before do
allow(Signal).to receive(:trap).with('INT') do |&block|
interrupt_handlers << block
end
end
def interrupt
interrupt_handlers.each(&:call)
end
it 'adds a handler for SIGINT' do
expect(interrupt_handlers).to be_empty
cli.trap_interrupt(runner)
expect(interrupt_handlers.size).to eq(1)
end
context 'with SIGINT once' do
it 'aborts processing' do
cli.trap_interrupt(runner)
expect(runner).to receive(:abort)
interrupt
end
it 'does not exit immediately' do
cli.trap_interrupt(runner)
expect_any_instance_of(Object).not_to receive(:exit)
expect_any_instance_of(Object).not_to receive(:exit!)
interrupt
end
end
context 'with SIGINT twice' do
it 'exits immediately' do
cli.trap_interrupt(runner)
expect_any_instance_of(Object).to receive(:exit!).with(1)
interrupt
interrupt
end
end
end
context 'when given a file/directory that is not under the current dir' do
shared_examples 'checks Rakefile' do
it 'checks a Rakefile but Style/FileName does not report' do
create_file('Rakefile', 'x = 1')
create_file('other/empty', '')
Dir.chdir('other') do
expect(cli.run(['--format', 'simple', checked_path])).to eq(1)
end
expect($stdout.string)
.to eq(["== #{abs('Rakefile')} ==",
'W: 1: 1: Useless assignment to variable - x.',
'',
'1 file inspected, 1 offense detected',
''].join("\n"))
end
end
context 'and the directory is absolute' do
let(:checked_path) { abs('..') }
include_examples 'checks Rakefile'
end
context 'and the directory is relative' do
let(:checked_path) { '..' }
include_examples 'checks Rakefile'
end
context 'and the Rakefile path is absolute' do
let(:checked_path) { abs('../Rakefile') }
include_examples 'checks Rakefile'
end
context 'and the Rakefile path is relative' do
let(:checked_path) { '../Rakefile' }
include_examples 'checks Rakefile'
end
end
context 'when lines end with CR+LF' do
it 'reports an offense' do
create_file('example.rb', ["x = 0\r",
"puts x\r"])
# Make Style/EndOfLine give same output regardless of platform.
create_file('.rubocop.yml', ['Style/EndOfLine:',
' EnforcedStyle: lf'])
result = cli.run(['--format', 'simple', 'example.rb'])
expect(result).to eq(1)
expect($stdout.string)
.to eq(['== example.rb ==',
'C: 1: 1: Carriage return character detected.',
'',
'1 file inspected, 1 offense detected',
''].join("\n"))
end
end
context 'when checking a correct file' do
it 'returns 0' do
create_file('example.rb', ['x = 0', 'puts x'])
expect(cli.run(['--format', 'simple', 'example.rb'])).to eq(0)
expect($stdout.string)
.to eq(['',
'1 file inspected, no offenses detected',
''].join("\n"))
end
context 'when super is used with a block' do
it 'still returns 0' do
create_file('example.rb', ['# frozen_string_literal: true',
'',
'# this is a class',
'class Thing',
' def super_with_block',
' super { |response| }',
' end',
'',
' def and_with_args',
' super(arg1, arg2) { |response| }',
' end',
'end'])
create_file('.rubocop.yml', ['Lint/UnusedBlockArgument:',
' IgnoreEmptyBlocks: true'])
expect(cli.run(['--format', 'simple', 'example.rb'])).to eq(0)
expect($stdout.string)
.to eq(['',
'1 file inspected, no offenses detected',
''].join("\n"))
end
end
end
it 'checks a given file with faults and returns 1' do
create_file('example.rb', ['x = 0 ', 'puts x'])
expect(cli.run(['--format', 'simple', 'example.rb'])).to eq(1)
expect($stdout.string)
.to eq ['== example.rb ==',
'C: 1: 6: Trailing whitespace detected.',
'',
'1 file inspected, 1 offense detected',
''].join("\n")
end
it 'registers an offense for a syntax error' do
create_file('example.rb', ['class Test', 'en'])
expect(cli.run(['--format', 'emacs', 'example.rb'])).to eq(1)
expect($stdout.string)
.to eq(["#{abs('example.rb')}:3:1: E: unexpected " \
'token $end (Using Ruby 2.1 parser; configure using ' \
'`TargetRubyVersion` parameter, under `AllCops`)',
''].join("\n"))
end
it 'registers an offense for Parser warnings' do
create_file('example.rb', ['puts *test', 'if a then b else c end'])
aggregate_failures('CLI output') do
expect(cli.run(['--format', 'emacs', 'example.rb'])).to eq(1)
expect($stdout.string)
.to eq(["#{abs('example.rb')}:1:6: W: " \
'Ambiguous splat operator. Parenthesize the method arguments ' \
"if it's surely a splat operator, or add a whitespace to the " \
'right of the `*` if it should be a multiplication.',
"#{abs('example.rb')}:2:1: C: " \
'Favor the ternary operator (`?:`) over `if/then/else/end` ' \
'constructs.',
''].join("\n"))
end
end
it 'can process a file with an invalid UTF-8 byte sequence' do
create_file('example.rb', ["# #{'f9'.hex.chr}#{'29'.hex.chr}"])
expect(cli.run(['--format', 'emacs', 'example.rb'])).to eq(1)
expect($stdout.string)
.to eq(["#{abs('example.rb')}:1:1: F: Invalid byte sequence in utf-8.",
''].join("\n"))
end
context 'when errors are raised while processing files due to bugs' do
let(:errors) do
['An error occurred while Encoding cop was inspecting file.rb.']
end
before do
allow_any_instance_of(RuboCop::Runner)
.to receive(:errors).and_return(errors)
end
it 'displays an error message to stderr' do
cli.run([])
expect($stderr.string)
.to include('1 error occurred:').and include(errors.first)
end
end
describe 'rubocop:disable comment' do
it 'can disable all cops in a code section' do
src = ['# rubocop:disable all',
'#' * 90,
'x(123456)',
'y("123")',
'def func',
' # rubocop: enable Metrics/LineLength,Style/StringLiterals',
' ' + '#' * 93,
' x(123456)',
' y("123")',
'end']
create_file('example.rb', src)
expect(cli.run(['--format', 'emacs', 'example.rb'])).to eq(1)
# all cops were disabled, then 2 were enabled again, so we
# should get 2 offenses reported.
expect($stdout.string)
.to eq(["#{abs('example.rb')}:7:81: C: Line is too long. [95/80]",
"#{abs('example.rb')}:9:5: C: Prefer single-quoted " \
"strings when you don't need string interpolation or " \
'special symbols.',
''].join("\n"))
end
context 'when --auto-correct is given' do
it 'does not trigger UnneededDisable due to lines moving around' do
src = ['a = 1 # rubocop:disable Lint/UselessAssignment']
create_file('example.rb', src)
create_file('.rubocop.yml', ['Style/FrozenStringLiteralComment:',
' Enabled: true',
' EnforcedStyle: always'])
expect(cli.run(['--format', 'offenses', '-a', 'example.rb'])).to eq(0)
expect($stdout.string).to eq(['',
'1 Style/EmptyLineAfterMagicComment',
'1 Style/FrozenStringLiteralComment',
'--',
'2 Total',
'',
''].join("\n"))
expect(IO.read('example.rb'))
.to eq(['# frozen_string_literal: true',
'',
'a = 1 # rubocop:disable Lint/UselessAssignment',
''].join("\n"))
end
end
it 'can disable selected cops in a code section' do
create_file('example.rb',
['# rubocop:disable Style/LineLength,' \
'Style/NumericLiterals,Style/StringLiterals',
'#' * 90,
'x(123456)',
'y("123")',
'def func',
' # rubocop: enable Metrics/LineLength, ' \
'Style/StringLiterals',
' ' + '#' * 93,
' x(123456)',
' y("123")',
'end'])
expect(cli.run(['--format', 'emacs', 'example.rb'])).to eq(1)
expect($stderr.string)
.to eq(["#{abs('example.rb')}: Style/LineLength has the wrong " \
'namespace - should be Metrics',
''].join("\n"))
# 3 cops were disabled, then 2 were enabled again, so we
# should get 2 offenses reported.
expect($stdout.string)
.to eq(["#{abs('example.rb')}:7:81: C: Line is too long. [95/80]",
"#{abs('example.rb')}:9:5: C: Prefer single-quoted " \
"strings when you don't need string interpolation or " \
'special symbols.',
''].join("\n"))
end
it 'can disable all cops on a single line' do
create_file('example.rb', 'y("123", 123456) # rubocop:disable all')
expect(cli.run(['--format', 'emacs', 'example.rb'])).to eq(0)
expect($stdout.string).to be_empty
end
it 'can disable selected cops on a single line' do
create_file('example.rb',
['a' * 90 + ' # rubocop:disable Metrics/LineLength',
'#' * 95,
'y("123", 123456) # rubocop:disable Style/StringLiterals,' \
'Style/NumericLiterals'])
expect(cli.run(['--format', 'emacs', 'example.rb'])).to eq(1)
expect($stdout.string)
.to eq(["#{abs('example.rb')}:2:81: C: Line is too long. [95/80]",
''].join("\n"))
end
context 'without using namespace' do
it 'can disable selected cops on a single line' do
create_file('example.rb',
['a' * 90 + ' # rubocop:disable LineLength',
'#' * 95,
'y("123") # rubocop:disable StringLiterals'])
expect(cli.run(['--format', 'emacs', 'example.rb'])).to eq(1)
expect($stdout.string)
.to eq(["#{abs('example.rb')}:2:81: C: Line is too long. [95/80]",
''].join("\n"))
end
end
context 'when not necessary' do
it 'causes an offense to be reported' do
create_file('example.rb',
['#' * 95,
'# rubocop:disable all',
'a' * 10 + ' # rubocop:disable LineLength,ClassLength',
'y(123) # rubocop:disable all'])
expect(cli.run(['--format', 'emacs', 'example.rb'])).to eq(1)
expect($stderr.string).to eq('')
expect($stdout.string)
.to eq(["#{abs('example.rb')}:1:81: C: Line is too long. [95/80]",
"#{abs('example.rb')}:2:1: W: Unnecessary disabling of " \
'all cops.',
"#{abs('example.rb')}:3:12: W: Unnecessary disabling of " \
'`Metrics/ClassLength`, `Metrics/LineLength`.',
"#{abs('example.rb')}:4:8: W: Unnecessary disabling of " \
'all cops.',
''].join("\n"))
end
context 'and there are no other offenses' do
it 'exits with error code' do
create_file('example.rb', 'a' * 10 + ' # rubocop:disable LineLength')
expect(cli.run(['example.rb'])).to eq(1)
end
end
shared_examples 'UnneededDisable not run' do |state, config|
context "and UnneededDisable is #{state}" do
it 'does not report UnneededDisable offenses' do
create_file('example.rb',
['#' * 95,
'# rubocop:disable all',
'a' * 10 + ' # rubocop:disable LineLength,ClassLength',
'y(123) # rubocop:disable all'])
create_file('.rubocop.yml', config.join("\n"))
expect(cli.run(['--format', 'emacs'])).to eq(1)
expect($stderr.string).to eq('')
expect($stdout.string)
.to eq(["#{abs('example.rb')}:1:81: C: Line is too long. [95/80]",
''].join("\n"))
end
end
end
include_examples 'UnneededDisable not run',
'individually disabled', ['Lint/UnneededDisable:',
' Enabled: false']
include_examples 'UnneededDisable not run',
'individually excluded', ['Lint/UnneededDisable:',
' Exclude:',
' - example.rb']
include_examples 'UnneededDisable not run',
'disabled through department', ['Lint:',
' Enabled: false']
end
end
it 'finds a file with no .rb extension but has a shebang line' do
create_file('example', ['#!/usr/bin/env ruby', 'x = 0', 'puts x'])
expect(cli.run(%w[--format simple])).to eq(0)
expect($stdout.string)
.to eq(['', '1 file inspected, no offenses detected', ''].join("\n"))
end
it 'does not register any offenses for an empty file' do
create_file('example.rb', '')
expect(cli.run(%w[--format simple])).to eq(0)
expect($stdout.string)
.to eq(['', '1 file inspected, no offenses detected', ''].join("\n"))
end
describe 'style guide only usage' do
context 'via the cli option' do
describe '--only-guide-cops' do
it 'skips cops that have no link to a style guide' do
create_file('example.rb', 'raise')
create_file('.rubocop.yml', ['Metrics/LineLength:',
' Enabled: true',
' StyleGuide: ~',
' Max: 2'])
expect(cli.run(['--format', 'simple', '--only-guide-cops',
'example.rb'])).to eq(0)
end
it 'runs cops for rules that link to a style guide' do
create_file('example.rb', 'raise')
create_file('.rubocop.yml', ['Metrics/LineLength:',
' Enabled: true',
' StyleGuide: "http://an.example/url"',
' Max: 2'])
expect(cli.run(['--format', 'simple', '--only-guide-cops',
'example.rb'])).to eq(1)
expect($stdout.string)
.to eq(['== example.rb ==',
'C: 1: 3: Line is too long. [5/2]',
'',
'1 file inspected, 1 offense detected',
''].join("\n"))
end
it 'overrides configuration of AllCops/StyleGuideCopsOnly' do
create_file('example.rb', 'raise')
create_file('.rubocop.yml', ['AllCops:',
' StyleGuideCopsOnly: false',
'Metrics/LineLength:',
' Enabled: true',
' StyleGuide: ~',
' Max: 2'])
expect(cli.run(['--format', 'simple', '--only-guide-cops',
'example.rb'])).to eq(0)
end
end
end
context 'via the config' do
before do
create_file('example.rb', 'do_something or raise')
create_file('.rubocop.yml',
['AllCops:',
" StyleGuideCopsOnly: #{guide_cops_only}",
" DisabledByDefault: #{disabled_by_default}",
'Metrics/LineLength:',
' Enabled: true',
' StyleGuide: ~',
' Max: 2'])
end
describe 'AllCops/StyleGuideCopsOnly' do
let(:disabled_by_default) { 'false' }
context 'when it is true' do
let(:guide_cops_only) { 'true' }
it 'skips cops that have no link to a style guide' do
expect(cli.run(['--format', 'offenses', 'example.rb'])).to eq(1)
expect($stdout.string.strip).to eq(['1 Style/AndOr',
'--',
'1 Total'].join("\n"))
end
end
context 'when it is false' do
let(:guide_cops_only) { 'false' }
it 'runs cops for rules regardless of any link to the style guide' do
expect(cli.run(['--format', 'offenses', 'example.rb'])).to eq(1)
expect($stdout.string.strip).to eq(['1 Metrics/LineLength',
'1 Style/AndOr',
'--',
'2 Total'].join("\n"))
end
end
end
describe 'AllCops/DisabledByDefault' do
let(:guide_cops_only) { 'false' }
context 'when it is true' do
let(:disabled_by_default) { 'true' }
it 'runs only the cop configured in .rubocop.yml' do
expect(cli.run(['--format', 'offenses', 'example.rb'])).to eq(1)
expect($stdout.string.strip).to eq(['1 Metrics/LineLength',
'--',
'1 Total'].join("\n"))
end
end
context 'when it is false' do
let(:disabled_by_default) { 'false' }
it 'runs all cops that are enabled in default configuration' do
expect(cli.run(['--format', 'offenses', 'example.rb'])).to eq(1)
expect($stdout.string.strip).to eq(['1 Metrics/LineLength',
'1 Style/AndOr',
'--',
'2 Total'].join("\n"))
end
end
end
end
end
describe 'rails cops' do
before(:each) do
RuboCop::ConfigLoader.default_configuration = nil
end
describe 'enabling/disabling' do
it 'by default does not run rails cops' do
create_file('app/models/example1.rb', 'read_attribute(:test)')
expect(cli.run(['--format', 'simple', 'app/models/example1.rb']))
.to eq(0)
end
it 'with -R given runs rails cops' do
create_file('app/models/example1.rb', 'read_attribute(:test)')
expect(cli.run(['--format', 'simple', '-R', 'app/models/example1.rb']))
.to eq(1)
expect($stdout.string).to include('Prefer self[:attr]')
end
it 'with configuration option true in one dir runs rails cops there' do
source = 'read_attribute(:test)'
create_file('dir1/app/models/example1.rb', source)
create_file('dir1/.rubocop.yml', ['Rails:',
' Enabled: true',
'',
'Rails/ReadWriteAttribute:',
' Include:',
' - app/models/**/*.rb'])
create_file('dir2/app/models/example2.rb', source)
create_file('dir2/.rubocop.yml', ['Rails:',
' Enabled: false',
'',
'Rails/ReadWriteAttribute:',
' Include:',
' - app/models/**/*.rb'])
expect(cli.run(%w[--format simple dir1 dir2])).to eq(1)
expect($stdout.string)
.to eq(['== dir1/app/models/example1.rb ==',
'C: 1: 1: Prefer self[:attr] over read_attribute' \
'(:attr).',
'',
'2 files inspected, 1 offense detected',
''].join("\n"))
end
it 'with configuration option false but -R given runs rails cops' do
create_file('app/models/example1.rb', 'read_attribute(:test)')
create_file('.rubocop.yml', ['Rails:',
' Enabled: false'])
expect(cli.run(['--format', 'simple', '-R', 'app/models/example1.rb']))
.to eq(1)
expect($stdout.string).to include('Prefer self[:attr]')
end
context 'with obsolete RunRailsCops config option' do
it 'prints a warning' do
create_file('.rubocop.yml', ['AllCops:',
' RunRailsCops: false'])
expect(cli.run([])).to eq(2)
expect($stderr.string).to include('obsolete parameter RunRailsCops ' \
'(for AllCops) found')
end
end
end
describe 'including/excluding' do
it 'honors Exclude settings in .rubocop_todo.yml one level up' do
create_file('lib/example.rb', 'puts %x(ls)')
create_file('.rubocop.yml', 'inherit_from: .rubocop_todo.yml')
create_file('.rubocop_todo.yml', ['Style/CommandLiteral:',
' Exclude:',
' - lib/example.rb'])
Dir.chdir('lib') { expect(cli.run([])).to eq(0) }
expect($stdout.string).to include('no offenses detected')
end
it 'includes some directories by default' do
source = ['read_attribute(:test)', "default_scope order: 'position'"]
# Several rails cops include app/models by default.
create_file('dir1/app/models/example1.rb', source)
create_file('dir1/app/models/example2.rb', source)
# No rails cops include app/views by default.
create_file('dir1/app/views/example3.rb', source)
# The .rubocop.yml file inherits from default.yml where the Include
# config parameter is set for the rails cops. The paths are interpreted
# as relative to dir1 because .rubocop.yml is placed there.
create_file('dir1/.rubocop.yml', ['Rails:',
' Enabled: true',
'',
'Rails/ReadWriteAttribute:',
' Exclude:',
' - "**/example2.rb"'])
# No .rubocop.yml file in dir2 means that the paths from default.yml
# are interpreted as relative to the current directory, so they don't
# match.
create_file('dir2/app/models/example4.rb', source)
expect(cli.run(%w[--format simple dir1 dir2])).to eq(1)
expect($stdout.string)
.to eq(['== dir1/app/models/example1.rb ==',
'C: 1: 1: Prefer self[:attr] over read_attribute' \
'(:attr).',
'',
'4 files inspected, 1 offense detected',
''].join("\n"))
end
end
end
describe 'cops can exclude files based on config' do
it 'ignores excluded files' do
create_file('example.rb', 'x = 0')
create_file('regexp.rb', 'x = 0')
create_file('exclude_glob.rb', ['#!/usr/bin/env ruby', 'x = 0'])
create_file('dir/thing.rb', 'x = 0')
create_file('.rubocop.yml', ['Lint/UselessAssignment:',
' Exclude:',
' - example.rb',
' - !ruby/regexp /regexp.rb\z/',
' - "exclude_*"',
' - "dir/*"'])
expect(cli.run(%w[--format simple])).to eq(0)
expect($stdout.string)
.to eq(['', '4 files inspected, no offenses detected',
''].join("\n"))
end
end
describe 'configuration from file' do
before(:each) do
RuboCop::ConfigLoader.default_configuration = nil
end
context 'when configured for rails style indentation' do
it 'accepts rails style indentation' do
create_file('.rubocop.yml', ['Style/IndentationConsistency:',
' EnforcedStyle: rails'])
create_file('example.rb', ['',
'# A feline creature',
'class Cat',
' def meow',
" puts('Meow!')",
' end',
'',
' protected',
'',
' def can_we_be_friends?(another_cat)',
' some_logic(another_cat)',
' end',
'',
' private',
'',
' def meow_at_3am?',
' rand < 0.8',
' end',
'end'])
result = cli.run(%w[--format simple])
expect($stderr.string).to eq('')
expect(result).to eq(0)
expect($stdout.string)
.to eq(['', '1 file inspected, no offenses detected',
''].join("\n"))
end
%w[class module].each do |parent|
it "registers offense for normal indentation in #{parent}" do
create_file('.rubocop.yml', ['Style/IndentationConsistency:',
' EnforcedStyle: rails'])
create_file('example.rb', ['',
'# A feline creature',
"#{parent} Cat",
' def meow',
" puts('Meow!')",
' end',
'',
' protected',
'',
' def can_we_be_friends?(another_cat)',
' some_logic(another_cat)',
' end',
'',
' private',
'',
' def meow_at_3am?',
' rand < 0.8',
' end',
'',
' def meow_at_4am?',
' rand < 0.8',
' end',
'end'])
result = cli.run(%w[--format simple])
expect($stderr.string).to eq('')
expect(result).to eq(1)
expect($stdout.string)
.to eq(['== example.rb ==',
'C: 10: 3: Use 2 (not 0) spaces for rails indentation.',
'C: 16: 3: Use 2 (not 0) spaces for rails indentation.',
'',
'1 file inspected, 2 offenses detected',
''].join("\n"))
end
end
end
context 'when obsolete MultiSpaceAllowedForOperators param is used' do
it 'displays a warning' do
create_file('.rubocop.yml', ['Style/SpaceAroundOperators:',
' MultiSpaceAllowedForOperators:',
' - "="'])
expect(cli.run([])).to eq(2)
expect($stderr.string).to include('obsolete parameter ' \
'MultiSpaceAllowedForOperators ' \
'(for Style/SpaceAroundOperators)' \
' found')
end
end
context 'when MultilineMethodCallIndentation is used with aligned ' \
'style and IndentationWidth parameter' do
it 'fails with an error message' do
create_file('example.rb', 'puts 1')
create_file('.rubocop.yml', ['Style/MultilineMethodCallIndentation:',
' EnforcedStyle: aligned',
' IndentationWidth: 1'])
expect(cli.run(['example.rb'])).to eq(2)
expect($stderr.string.strip).to eq(
'Error: The `Style/MultilineMethodCallIndentation` cop only accepts' \
' an `IndentationWidth` configuration parameter when ' \
'`EnforcedStyle` is `indented`.'
)
end
end
context 'when MultilineOperationIndentation is used with aligned ' \
'style and IndentationWidth parameter' do
it 'fails with an error message' do
create_file('example.rb', 'puts 1')
create_file('.rubocop.yml', ['Style/MultilineOperationIndentation:',
' EnforcedStyle: aligned',
' IndentationWidth: 1'])
expect(cli.run(['example.rb'])).to eq(2)
expect($stderr.string.strip).to eq(
'Error: The `Style/MultilineOperationIndentation` cop only accepts' \
' an `IndentationWidth` configuration parameter when ' \
'`EnforcedStyle` is `indented`.'
)
end
end
it 'allows the default configuration file as the -c argument' do
create_file('example.rb', ['x = 0', 'puts x'])
create_file('.rubocop.yml', [])
expect(cli.run(%w[--format simple -c .rubocop.yml])).to eq(0)
expect($stdout.string)
.to eq(['', '1 file inspected, no offenses detected',
''].join("\n"))
end
context 'when --force-default-config option is specified' do
shared_examples 'ignores config file' do
it 'ignores config file' do
create_file('example.rb', ['x = 0 ', 'puts x'])
create_file('.rubocop.yml', ['Style/TrailingWhitespace:',
' Enabled: false'])
expect(cli.run(args)).to eq(1)
expect($stdout.string)
.to eq(['== example.rb ==',
'C: 1: 6: Trailing whitespace detected.',
'',
'1 file inspected, 1 offense detected',
''].join("\n"))
end
end
context 'when no config file specified' do
let(:args) { %w[--format simple --force-default-config] }
include_examples 'ignores config file'
end
context 'when config file specified with -c' do
let(:args) do
%w[--format simple --force-default-config -c .rubocop.yml]
end
include_examples 'ignores config file'
end
end
it 'displays cop names if DisplayCopNames is true' do
source = ['x = 0 ', 'puts x']
create_file('example1.rb', source)
# DisplayCopNames: false inherited from config/default.yml
create_file('.rubocop.yml', [])
create_file('dir/example2.rb', source)
create_file('dir/.rubocop.yml', ['AllCops:',
' DisplayCopNames: true'])
expect(cli.run(%w[--format simple])).to eq(1)
expect($stdout.string)
.to eq(['== example1.rb ==',
'C: 1: 6: Trailing whitespace detected.',
'== dir/example2.rb ==',
'C: 1: 6: Style/TrailingWhitespace: Trailing whitespace' \
' detected.',
'',
'2 files inspected, 2 offenses detected',
''].join("\n"))
end
it 'displays style guide URLs if DisplayStyleGuide is true' do
source = ['x = 0 ', 'puts x']
create_file('example1.rb', source)
# DisplayCopNames: false inherited from config/default.yml
create_file('.rubocop.yml', [])
create_file('dir/example2.rb', source)
create_file('dir/.rubocop.yml', ['AllCops:',
' DisplayStyleGuide: true'])
url = 'https://github.com/bbatsov/ruby-style-guide#no-trailing-whitespace'
expect(cli.run(%w[--format simple])).to eq(1)
expect($stdout.string)
.to eq(['== example1.rb ==',
'C: 1: 6: Trailing whitespace detected.',
'== dir/example2.rb ==',
'C: 1: 6: Trailing whitespace' \
" detected. (#{url})",
'',
'2 files inspected, 2 offenses detected',
''].join("\n"))
end
it 'uses the DefaultFormatter if another formatter is not specified' do
source = ['x = 0 ', 'puts x']
create_file('example1.rb', source)
create_file('.rubocop.yml', ['AllCops:',
' DefaultFormatter: offenses'])
expect(cli.run([])).to eq(1)
expect($stdout.string.strip)
.to eq(['1 Style/TrailingWhitespace',
'--',
'1 Total'].join("\n"))
end
it 'finds included files' do
create_file('file.rb', 'x=0') # Included by default
create_file('example', 'x=0')
create_file('regexp', 'x=0')
create_file('.dot1/file.rb', 'x=0') # Hidden but explicitly included
create_file('.dot2/file.rb', 'x=0') # Hidden, excluded by default
create_file('.dot3/file.rake', 'x=0') # Hidden, not included by wildcard
create_file('.rubocop.yml', ['AllCops:',
' Include:',
' - example',
' - "**/*.rake"',
' - !ruby/regexp /regexp$/',
' - .dot1/**/*'])
expect(cli.run(%w[--format files])).to eq(1)
expect($stderr.string).to eq('')
expect($stdout.string.split($RS).sort).to eq([abs('.dot1/file.rb'),
abs('example'),
abs('file.rb'),
abs('regexp')])
end
it 'ignores excluded files' do
create_file('example.rb', ['x = 0', 'puts x'])
create_file('regexp.rb', ['x = 0', 'puts x'])
create_file('exclude_glob.rb', ['#!/usr/bin/env ruby', 'x = 0', 'puts x'])
create_file('.rubocop.yml', ['AllCops:',
' Exclude:',
' - example.rb',
' - !ruby/regexp /regexp.rb$/',
' - "exclude_*"'])
expect(cli.run(%w[--format simple])).to eq(0)
expect($stdout.string)
.to eq(['', '0 files inspected, no offenses detected',
''].join("\n"))
end
it 'only reads configuration in explicitly included hidden directories' do
create_file('.hidden/example.rb', 'x=0')
# This file contains configuration for an unknown cop. This would cause a
# warning to be printed on stderr if the file was read. But it's in a
# hidden directory, so it's not read.
create_file('.hidden/.rubocop.yml', ['SymbolName:',
' Enabled: false'])
create_file('.other/example.rb', 'x=0')
# The .other directory is explicitly included, so the configuration file
# is read, and modifies the behavior.
create_file('.other/.rubocop.yml', ['Style/SpaceAroundOperators:',
' Enabled: false'])
create_file('.rubocop.yml', ['AllCops:',
' Include:',
' - .other/**/*'])
expect(cli.run(%w[--format simple])).to eq(1)
expect($stderr.string).to eq('')
expect($stdout.string)
.to eq(['== .other/example.rb ==',
'W: 1: 1: Useless assignment to variable - x.',
'',
'1 file inspected, 1 offense detected',
''].join("\n"))
end
it 'does not consider Include parameters in subdirectories' do
create_file('dir/example.ruby3', 'x=0')
create_file('dir/.rubocop.yml', ['AllCops:',
' Include:',
' - "*.ruby3"'])
expect(cli.run(%w[--format simple])).to eq(0)
expect($stderr.string).to eq('')
expect($stdout.string)
.to eq(['',
'0 files inspected, no offenses detected',
''].join("\n"))
end
it 'matches included/excluded files correctly when . argument is given' do
create_file('example.rb', 'x = 0')
create_file('special.dsl', 'setup { "stuff" }')
create_file('.rubocop.yml', ['AllCops:',
' Include:',
' - "*.dsl"',
' Exclude:',
' - example.rb'])
expect(cli.run(%w[--format simple .])).to eq(1)
expect($stdout.string)
.to eq(['== special.dsl ==',
"C: 1: 9: Prefer single-quoted strings when you don't " \
'need string interpolation or special symbols.',
'',
'1 file inspected, 1 offense detected',
''].join("\n"))
end
# With rubinius 2.0.0.rc1 + rspec 2.13.1,
# File.stub(:open).and_call_original causes SystemStackError.
it 'does not read files in excluded list', broken: :rbx do
%w[rb.rb non-rb.ext without-ext].each do |filename|
create_file("example/ignored/#{filename}", '#' * 90)
end
create_file('example/.rubocop.yml', ['AllCops:',
' Exclude:',
' - ignored/**'])
expect(File).not_to receive(:open).with(%r{/ignored/})
allow(File).to receive(:open).and_call_original
expect(cli.run(%w[--format simple example])).to eq(0)
expect($stdout.string)
.to eq(['', '0 files inspected, no offenses detected',
''].join("\n"))
end
it 'can be configured with option to disable a certain error' do
create_file('example1.rb', 'puts 0 ')
create_file('rubocop.yml', ['Style/Encoding:',
' Enabled: false',
'',
'Style/CaseIndentation:',
' Enabled: false'])
expect(cli.run(['--format', 'simple',
'-c', 'rubocop.yml', 'example1.rb'])).to eq(1)
expect($stdout.string)
.to eq(['== example1.rb ==',
'C: 1: 7: Trailing whitespace detected.',
'',
'1 file inspected, 1 offense detected',
''].join("\n"))
end
context 'without using namespace' do
it 'can be configured with option to disable a certain error' do
create_file('example1.rb', 'puts 0 ')
create_file('rubocop.yml', ['Encoding:',
' Enabled: false',
'',
'CaseIndentation:',
' Enabled: false'])
expect(cli.run(['--format', 'simple',
'-c', 'rubocop.yml', 'example1.rb'])).to eq(1)
expect($stdout.string)
.to eq(['== example1.rb ==',
'C: 1: 7: Trailing whitespace detected.',
'',
'1 file inspected, 1 offense detected',
''].join("\n"))
end
end
it 'can disable parser-derived offenses with warning severity' do
# `-' interpreted as argument prefix
create_file('example.rb', 'puts -1')
create_file('.rubocop.yml', ['Style/Encoding:',
' Enabled: false',
'',
'Lint/AmbiguousOperator:',
' Enabled: false'])
expect(cli.run(['--format', 'emacs', 'example.rb'])).to eq(0)
end
it 'cannot disable Syntax offenses' do
create_file('example.rb', 'class Test')
create_file('.rubocop.yml', ['Style/Encoding:',
' Enabled: false',
'',
'Syntax:',
' Enabled: false'])
expect(cli.run(['--format', 'emacs', 'example.rb'])).to eq(2)
expect($stderr.string).to include(
'Error: configuration for Syntax cop found'
)
expect($stderr.string).to include('This cop cannot be configured.')
end
it 'can be configured to merge a parameter that is a hash' do
create_file('example1.rb', ['puts %w(a b c)', 'puts %q|hi|'])
# We want to change the preferred delimiters for word arrays. The other
# settings from default.yml are unchanged.
create_file('rubocop.yml',
['Style/PercentLiteralDelimiters:',
' PreferredDelimiters:',
" '%w': '[]'",
" '%W': '[]'"])
cli.run(['--format', 'simple', '-c', 'rubocop.yml', 'example1.rb'])
expect($stdout.string)
.to eq(['== example1.rb ==',
'C: 1: 6: %w-literals should be delimited by [ and ].',
'C: 2: 6: %q-literals should be delimited by ( and ).',
'C: 2: 6: Use %q only for strings that contain both single ' \
'quotes and double quotes.',
'',
'1 file inspected, 3 offenses detected',
''].join("\n"))
end
it 'can be configured to override a parameter that is a hash in a ' \
'special case' do
create_file('example1.rb',
['arr.select { |e| e > 0 }.collect { |e| e * 2 }',
'a2.find_all { |e| e > 0 }'])
# We prefer find_all over select. This setting overrides the default
# select over find_all. Other preferred methods appearing in the default
# config (e.g., map over collect) are kept.
create_file('rubocop.yml',
['Style/CollectionMethods:',
' PreferredMethods:',
' select: find_all'])
cli.run(['--format',
'simple',
'-c',
'rubocop.yml',
'--only',
'CollectionMethods',
'example1.rb'])
expect($stdout.string)
.to eq(['== example1.rb ==',
'C: 1: 5: Prefer find_all over select.',
'C: 1: 26: Prefer map over collect.',
'',
'1 file inspected, 2 offenses detected',
''].join("\n"))
end
it 'works when a cop that others depend on is disabled' do
create_file('example1.rb', ['if a',
' b',
'end'])
create_file('rubocop.yml', ['Style/Encoding:',
' Enabled: false',
'',
'Metrics/LineLength:',
' Enabled: false'])
result = cli.run(['--format', 'simple',
'-c', 'rubocop.yml', 'example1.rb'])
expect($stdout.string)
.to eq(['== example1.rb ==',
'C: 1: 1: Favor modifier if usage when having ' \
'a single-line body. Another good alternative is the ' \
'usage of control flow &&/||.',
'',
'1 file inspected, 1 offense detected',
''].join("\n"))
expect(result).to eq(1)
end
it 'can be configured with project config to disable a certain error' do
create_file('example_src/example1.rb', 'puts 0 ')
create_file('example_src/.rubocop.yml', ['Style/Encoding:',
' Enabled: false',
'',
'Style/CaseIndentation:',
' Enabled: false'])
expect(cli.run(['--format', 'simple',
'example_src/example1.rb'])).to eq(1)
expect($stdout.string)
.to eq(['== example_src/example1.rb ==',
'C: 1: 7: Trailing whitespace detected.',
'',
'1 file inspected, 1 offense detected',
''].join("\n"))
end
it 'can use an alternative max line length from a config file' do
create_file('example_src/example1.rb', '#' * 90)
create_file('example_src/.rubocop.yml', ['Metrics/LineLength:',
' Enabled: true',
' Max: 100'])
expect(cli.run(['--format', 'simple',
'example_src/example1.rb'])).to eq(0)
expect($stdout.string)
.to eq(['', '1 file inspected, no offenses detected', ''].join("\n"))
end
it 'can have different config files in different directories' do
%w[src lib].each do |dir|
create_file("example/#{dir}/example1.rb", '#' * 90)
end
create_file('example/src/.rubocop.yml', ['Metrics/LineLength:',
' Enabled: true',
' Max: 100'])
expect(cli.run(%w[--format simple example])).to eq(1)
expect($stdout.string).to eq(['== example/lib/example1.rb ==',
'C: 1: 81: Line is too long. [90/80]',
'',
'2 files inspected, 1 offense detected',
''].join("\n"))
end
it 'prefers a config file in ancestor directory to another in home' do
create_file('example_src/example1.rb', '#' * 90)
create_file('example_src/.rubocop.yml', ['Metrics/LineLength:',
' Enabled: true',
' Max: 100'])
create_file("#{Dir.home}/.rubocop.yml", ['Metrics/LineLength:',
' Enabled: true',
' Max: 80'])
expect(cli.run(['--format', 'simple',
'example_src/example1.rb'])).to eq(0)
expect($stdout.string)
.to eq(['', '1 file inspected, no offenses detected', ''].join("\n"))
end
it 'can exclude directories relative to .rubocop.yml' do
%w[src etc/test etc/spec tmp/test tmp/spec].each do |dir|
create_file("example/#{dir}/example1.rb", '#' * 90)
end
# Hidden subdirectories should also be excluded.
create_file('example/etc/.dot/example1.rb', '#' * 90)
create_file('example/.rubocop.yml', ['AllCops:',
' Exclude:',
' - src/**',
' - etc/**/*',
' - tmp/spec/**'])
expect(cli.run(%w[--format simple example])).to eq(1)
expect($stderr.string).to eq('')
expect($stdout.string).to eq(['== example/tmp/test/example1.rb ==',
'C: 1: 81: Line is too long. [90/80]',
'',
'1 file inspected, 1 offense detected',
''].join("\n"))
end
it 'can exclude a typical vendor directory' do
create_file('vendor/bundle/ruby/1.9.1/gems/parser-2.0.0/.rubocop.yml',
['AllCops:',
' Exclude:',
' - lib/parser/lexer.rb'])
create_file('vendor/bundle/ruby/1.9.1/gems/parser-2.0.0/lib/ex.rb',
'#' * 90)
create_file('.rubocop.yml',
['AllCops:',
' Exclude:',
' - vendor/**/*'])
cli.run(%w[--format simple])
expect($stdout.string)
.to eq(['', '0 files inspected, no offenses detected',
''].join("\n"))
end
it 'excludes the vendor directory by default' do
create_file('vendor/ex.rb', '#' * 90)
cli.run(%w[--format simple])
expect($stdout.string)
.to eq(['', '0 files inspected, no offenses detected',
''].join("\n"))
end
# Being immune to bad configuration files in excluded directories has
# become important due to a bug in rubygems
# (https://github.com/rubygems/rubygems/issues/680) that makes
# installations of, for example, rubocop lack their .rubocop.yml in the
# root directory.
it 'can exclude a vendor directory with an erroneous config file' do
create_file('vendor/bundle/ruby/1.9.1/gems/parser-2.0.0/.rubocop.yml',
['inherit_from: non_existent.yml'])
create_file('vendor/bundle/ruby/1.9.1/gems/parser-2.0.0/lib/ex.rb',
'#' * 90)
create_file('.rubocop.yml',
['AllCops:',
' Exclude:',
' - vendor/**/*'])
cli.run(%w[--format simple])
expect($stderr.string).to eq('')
expect($stdout.string)
.to eq(['', '0 files inspected, no offenses detected',
''].join("\n"))
end
# Relative exclude paths in .rubocop.yml files are relative to that file,
# but in configuration files with other names they will be relative to
# whatever file inherits from them.
it 'can exclude a vendor directory indirectly' do
create_file('vendor/bundle/ruby/1.9.1/gems/parser-2.0.0/.rubocop.yml',
['AllCops:',
' Exclude:',
' - lib/parser/lexer.rb'])
create_file('vendor/bundle/ruby/1.9.1/gems/parser-2.0.0/lib/ex.rb',
'#' * 90)
create_file('.rubocop.yml',
['inherit_from: config/default.yml'])
create_file('config/default.yml',
['AllCops:',
' Exclude:',
' - vendor/**/*'])
cli.run(%w[--format simple])
expect($stdout.string)
.to eq(['', '0 files inspected, no offenses detected',
''].join("\n"))
end
it 'prints a warning for an unrecognized cop name in .rubocop.yml' do
create_file('example/example1.rb', '#' * 90)
create_file('example/.rubocop.yml', ['Style/LyneLenth:',
' Enabled: true',
' Max: 100'])
expect(cli.run(%w[--format simple example])).to eq(1)
expect($stderr.string)
.to eq(['Warning: unrecognized cop Style/LyneLenth found in ' +
abs('example/.rubocop.yml'),
''].join("\n"))
end
it 'prints a warning for an unrecognized configuration parameter' do
create_file('example/example1.rb', '#' * 90)
create_file('example/.rubocop.yml', ['Metrics/LineLength:',
' Enabled: true',
' Min: 10'])
expect(cli.run(%w[--format simple example])).to eq(1)
expect($stderr.string)
.to eq(['Warning: unrecognized parameter Metrics/LineLength:Min ' \
'found in ' + abs('example/.rubocop.yml'),
''].join("\n"))
end
it 'prints an error message for an unrecognized EnforcedStyle' do
create_file('example/example1.rb', 'puts "hello"')
create_file('example/.rubocop.yml', ['Style/BracesAroundHashParameters:',
' EnforcedStyle: context'])
expect(cli.run(%w[--format simple example])).to eq(2)
expect($stderr.string)
.to eq(["Error: invalid EnforcedStyle 'context' for " \
'Style/BracesAroundHashParameters found in ' +
abs('example/.rubocop.yml'),
'Valid choices are: braces, no_braces, context_dependent',
''].join("\n"))
end
it 'works when a configuration file passed by -c specifies Exclude ' \
'with regexp' do
create_file('example/example1.rb', '#' * 90)
create_file('rubocop.yml', ['AllCops:',
' Exclude:',
' - !ruby/regexp /example1\.rb$/'])
cli.run(%w[--format simple -c rubocop.yml])
expect($stdout.string)
.to eq(['', '0 files inspected, no offenses detected',
''].join("\n"))
end
it 'works when a configuration file passed by -c specifies Exclude ' \
'with strings' do
create_file('example/example1.rb', '#' * 90)
create_file('rubocop.yml', ['AllCops:',
' Exclude:',
' - example/**'])
cli.run(%w[--format simple -c rubocop.yml])
expect($stdout.string)
.to eq(['', '0 files inspected, no offenses detected',
''].join("\n"))
end
it 'works when a configuration file specifies a Severity' do
create_file('example/example1.rb', '#' * 90)
create_file('rubocop.yml', ['Metrics/LineLength:',
' Severity: error'])
cli.run(%w[--format simple -c rubocop.yml])
expect($stdout.string)
.to eq(['== example/example1.rb ==',
'E: 1: 81: Line is too long. [90/80]',
'',
'1 file inspected, 1 offense detected',
''].join("\n"))
expect($stderr.string).to eq('')
end
it 'fails when a configuration file specifies an invalid Severity' do
create_file('example/example1.rb', '#' * 90)
create_file('rubocop.yml', ['Metrics/LineLength:',
' Severity: superbad'])
cli.run(%w[--format simple -c rubocop.yml])
expect($stderr.string)
.to eq(["Warning: Invalid severity 'superbad'. " \
'Valid severities are refactor, convention, ' \
'warning, error, fatal.',
''].join("\n"))
end
it 'fails when a configuration file has invalid YAML syntax' do
create_file('example/.rubocop.yml', ['AllCops:',
' Exclude:',
' - **/*_old.rb'])
cli.run(['example'])
# MRI and JRuby return slightly different error messages.
expect($stderr.string)
.to match(%r{^\(\S+example/\.rubocop\.yml\):\ (did\ not\ find\ )?
expected\ alphabetic\ or \ numeric\ character}x)
end
context 'when a file inherits from a higher level' do
before do
create_file('.rubocop.yml', ['Metrics/LineLength:',
' Exclude:',
' - dir/example.rb'])
create_file('dir/.rubocop.yml', 'inherit_from: ../.rubocop.yml')
create_file('dir/example.rb', '#' * 90)
end
it 'inherits relative excludes correctly' do
expect(cli.run([])).to eq(0)
end
end
context 'when configuration is taken from $HOME/.rubocop.yml' do
before do
create_file("#{Dir.home}/.rubocop.yml", ['Metrics/LineLength:',
' Exclude:',
' - dir/example.rb'])
create_file('dir/example.rb', '#' * 90)
end
it 'handles relative excludes correctly when run from project root' do
expect(cli.run([])).to eq(0)
end
end
it 'shows an error if the input file cannot be found' do
begin
cli.run(%w[/tmp/not_a_file])
rescue SystemExit => e
expect(e.status).to eq(1)
expect(e.message)
.to eq 'rubocop: No such file or directory -- /tmp/not_a_file'
end
end
end
describe 'configuration of target Ruby versions' do
context 'when configured with an unknown version' do
it 'fails with an error message' do
create_file('.rubocop.yml', ['AllCops:',
' TargetRubyVersion: 2.5'])
expect(cli.run([])).to eq(2)
expect($stderr.string.strip).to match(
/\AError: Unknown Ruby version 2.5 found in `TargetRubyVersion`/
)
expect($stderr.string.strip).to match(
/Known versions: 1.9, 2.0, 2.1, 2.2, 2.3, 2.4/
)
end
end
context 'when set to 1.9 and Style/OptionHash is enabled' do
it 'fails with an error message' do
create_file('example1.rb', "puts 'hello'")
create_file('.rubocop.yml', ['AllCops:',
' TargetRubyVersion: 1.9',
'Style/OptionHash:',
' Enabled: true'])
expect(cli.run(['example1.rb'])).to eq(2)
expect($stderr.string.strip).to eq(
['Error: The `Style/OptionHash` cop is only compatible with Ruby ' \
'2.0 and up, but the target Ruby version for your project is 1.9.',
'Please disable this cop or adjust the `TargetRubyVersion` ' \
'parameter in your configuration.'].join("\n")
)
end
end
end
describe 'obsolete cops' do
context 'when configuration for TrailingComma is given' do
it 'fails with an error message' do
create_file('example1.rb', "puts 'hello'")
create_file('.rubocop.yml', ['Style/TrailingComma:',
' Enabled: true'])
expect(cli.run(['example1.rb'])).to eq(2)
expect($stderr.string.strip).to eq(
['Error: The `Style/TrailingComma` cop no longer exists. Please ' \
'use `Style/TrailingCommaInLiteral` and/or ' \
'`Style/TrailingCommaInArguments` instead.',
"(obsolete configuration found in #{abs('.rubocop.yml')}, " \
'please update it)'].join("\n")
)
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/comment_config_spec.rb 0000664 0000000 0000000 00000013661 13070542236 0024075 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::CommentConfig do
subject(:comment_config) { described_class.new(parse_source(source)) }
describe '#cop_enabled_at_line?' do
let(:source) do
[
'# rubocop:disable Metrics/MethodLength with a comment why',
'def some_method',
" puts 'foo'", # 3
'end',
'# rubocop:enable Metrics/MethodLength',
'',
'# rubocop:disable all',
'some_method', # 8
'# rubocop:enable all',
'',
"code = 'This is evil.'",
'eval(code) # rubocop:disable Security/Eval',
"puts 'This is not evil.'", # 12
'',
'def some_method',
" puts 'Disabling indented single line' # rubocop:disable " \
'Metrics/LineLength',
'end',
'', # 18
'string = < 40..42,
'Lint/RandOne' => 40..43,
'Lint/BlockAlignment' => 41..42
}.each do |cop_name, expected|
actual = disabled_lines_of_cop(cop_name)
expect(actual & expected.to_a).to eq(expected.to_a)
end
end
it 'supports enabling/disabling cops without a prefix' do
flat_map_disabled_lines = disabled_lines_of_cop('Performance/FlatMap')
expected = (44..46).to_a
expect(flat_map_disabled_lines & expected).to eq(expected)
end
it 'supports disabling all lines after a directive' do
for_disabled_lines = disabled_lines_of_cop('Style/For')
expected_part = (27..source.size).to_a
expect(for_disabled_lines & expected_part).to eq(expected_part)
end
it 'just ignores unpaired enabling directives' do
void_disabled_lines = disabled_lines_of_cop('Lint/Void')
expected_part = (25..source.size).to_a
expect(void_disabled_lines & expected_part).to be_empty
end
it 'supports disabling single line with a directive at end of line' do
eval_disabled_lines = disabled_lines_of_cop('Security/Eval')
expect(eval_disabled_lines).to include(12)
expect(eval_disabled_lines).not_to include(13)
end
it 'handles indented single line' do
line_length_disabled_lines = disabled_lines_of_cop('Metrics/LineLength')
expect(line_length_disabled_lines).to include(16)
expect(line_length_disabled_lines).not_to include(18)
end
it 'does not confuse a comment directive embedded in a string literal ' \
'with a real comment' do
loop_disabled_lines = disabled_lines_of_cop('Loop')
expect(loop_disabled_lines).not_to include(20)
end
it 'supports disabling all cops except Lint/UnneededDisable with ' \
'keyword all' do
expected_part = (7..8).to_a
cops = RuboCop::Cop::Cop.all.reject do |klass|
klass == RuboCop::Cop::Lint::UnneededDisable
end
cops.each do |cop|
disabled_lines = disabled_lines_of_cop(cop)
expect(disabled_lines & expected_part).to eq(expected_part)
end
end
it 'does not confuse a cop name including "all" with all cops' do
alias_disabled_lines = disabled_lines_of_cop('Alias')
expect(alias_disabled_lines).not_to include(23)
end
it 'can handle double disable of one cop' do
expect(disabled_lines_of_cop('Style/ClassVars'))
.to eq([7, 8, 9] + (31..source.size).to_a)
end
it 'supports disabling cops with multiple uppercase letters' do
expect(disabled_lines_of_cop('RSpec/Example')).to include(47)
end
it 'supports disabling cops with numbers in their name' do
expect(disabled_lines_of_cop('Custom2/Number9')).to include(48)
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/config_loader_spec.rb 0000664 0000000 0000000 00000056437 13070542236 0023711 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::ConfigLoader do
include FileHelper
let(:default_config) { described_class.default_configuration }
describe '.configuration_file_for', :isolated_environment do
subject(:configuration_file_for) do
described_class.configuration_file_for(dir_path)
end
context 'when no config file exists in ancestor directories' do
let(:dir_path) { 'dir' }
before { create_file('dir/example.rb', '') }
context 'but a config file exists in home directory' do
before { create_file('~/.rubocop.yml', '') }
it 'returns the path to the file in home directory' do
expect(configuration_file_for).to end_with('home/.rubocop.yml')
end
end
context 'and no config file exists in home directory' do
it 'falls back to the provided default file' do
expect(configuration_file_for).to end_with('config/default.yml')
end
end
context 'and ENV has no `HOME` defined' do
before { ENV.delete 'HOME' }
it 'falls back to the provided default file' do
expect(configuration_file_for).to end_with('config/default.yml')
end
end
end
context 'when a config file exists in the parent directory' do
let(:dir_path) { 'dir' }
before do
create_file('dir/example.rb', '')
create_file('.rubocop.yml', '')
end
it 'returns the path to that configuration file' do
expect(configuration_file_for).to end_with('work/.rubocop.yml')
end
end
context 'when multiple config files exist in ancestor directories' do
let(:dir_path) { 'dir' }
before do
create_file('dir/example.rb', '')
create_file('dir/.rubocop.yml', '')
create_file('.rubocop.yml', '')
end
it 'prefers closer config file' do
expect(configuration_file_for).to end_with('dir/.rubocop.yml')
end
end
end
describe '.configuration_from_file', :isolated_environment do
subject(:configuration_from_file) do
described_class.configuration_from_file(file_path)
end
context 'with any config file' do
let(:file_path) { '.rubocop.yml' }
before do
create_file(file_path, ['Style/Encoding:',
' Enabled: false'])
end
it 'returns a configuration inheriting from default.yml' do
config = default_config['Style/Encoding'].dup
config['Enabled'] = false
expect(configuration_from_file.to_h)
.to eql(default_config.merge('Style/Encoding' => config))
end
end
context 'when multiple config files exist in ancestor directories' do
let(:file_path) { 'dir/.rubocop.yml' }
before do
create_file('.rubocop.yml',
['AllCops:',
' Exclude:',
' - vendor/**'])
create_file(file_path,
['AllCops:',
' Exclude: []'])
end
it 'gets AllCops/Exclude from the highest directory level' do
excludes = configuration_from_file['AllCops']['Exclude']
expect(excludes).to eq([File.expand_path('vendor/**')])
end
end
context 'when a parent file specifies DisabledByDefault: true' do
let(:file_path) { '.rubocop.yml' }
before do
create_file('disable.yml',
['AllCops:',
' DisabledByDefault: true'])
create_file(file_path, ['inherit_from: disable.yml'])
end
it 'disables cops by default' do
cop_options = configuration_from_file['Style/Alias']
expect(cop_options.fetch('Enabled')).to be(false)
end
end
context 'when a file inherits from a parent file' do
let(:file_path) { 'dir/.rubocop.yml' }
before do
create_file('.rubocop.yml',
['AllCops:',
' Exclude:',
' - vendor/**',
' - !ruby/regexp /[A-Z]/'])
create_file(file_path, ['inherit_from: ../.rubocop.yml'])
end
it 'gets an absolute AllCops/Exclude' do
excludes = configuration_from_file['AllCops']['Exclude']
expect(excludes).to eq([File.expand_path('vendor/**'), /[A-Z]/])
end
end
context 'when a file inherits from an empty parent file' do
let(:file_path) { 'dir/.rubocop.yml' }
before do
create_file('.rubocop.yml', [''])
create_file(file_path, ['inherit_from: ../.rubocop.yml'])
end
it 'does not fail to load' do
expect { configuration_from_file }.not_to raise_error
end
end
context 'when a file inherits from a sibling file' do
let(:file_path) { 'dir/.rubocop.yml' }
before do
create_file('src/.rubocop.yml',
['AllCops:',
' Exclude:',
' - vendor/**'])
create_file(file_path, ['inherit_from: ../src/.rubocop.yml'])
end
it 'gets an absolute AllCops/Exclude' do
excludes = configuration_from_file['AllCops']['Exclude']
expect(excludes).to eq([File.expand_path('src/vendor/**')])
end
end
context 'when a third party require defines a new gem' do
before do
allow(RuboCop::Cop::Cop)
.to receive(:registry)
.and_return(
RuboCop::Cop::Registry.new(RuboCop::Cop::Cop.registry.cops)
)
create_file('third_party/gem.rb',
['module RuboCop',
' module Cop',
' module Custom',
' class FilePath < Cop',
' end',
' end',
' end',
'end'])
create_file('.rubocop.yml',
['Custom/FilePath:',
' Enabled: false'])
create_file('.rubocop_with_require.yml',
['require: ./third_party/gem',
'Custom/FilePath:',
' Enabled: false'])
end
it 'does not emit a warning' do
aggregate_failures('loads requires before resolving namespace') do
expect { described_class.configuration_from_file('.rubocop.yml') }
.to output(
a_string_including(
'.rubocop.yml: Custom/FilePath has the ' \
"wrong namespace - should be Rails\n"
)
).to_stderr
expect do
described_class.configuration_from_file('.rubocop_with_require.yml')
end.not_to output.to_stderr
end
end
end
context 'when a file inherits from a parent and grandparent file' do
let(:file_path) { 'dir/subdir/.rubocop.yml' }
before do
create_file('dir/subdir/example.rb', '')
create_file('.rubocop.yml',
['Metrics/LineLength:',
' Enabled: false',
' Max: 77'])
create_file('dir/.rubocop.yml',
['inherit_from: ../.rubocop.yml',
'',
'Metrics/MethodLength:',
' Enabled: true',
' CountComments: false',
' Max: 10'])
create_file(file_path,
['inherit_from: ../.rubocop.yml',
'',
'Metrics/LineLength:',
' Enabled: true',
'',
'Metrics/MethodLength:',
' Max: 5'])
end
it 'returns the ancestor configuration plus local overrides' do
config =
default_config.merge(
'Metrics/LineLength' => {
'Description' =>
default_config['Metrics/LineLength']['Description'],
'StyleGuide' => '#80-character-limits',
'Enabled' => true,
'Max' => 77,
'AllowHeredoc' => true,
'AllowURI' => true,
'URISchemes' => %w[http https],
'IgnoreCopDirectives' => false,
'IgnoredPatterns' => []
},
'Metrics/MethodLength' => {
'Description' =>
default_config['Metrics/MethodLength']['Description'],
'StyleGuide' => '#short-methods',
'Enabled' => true,
'CountComments' => false,
'Max' => 5
}
)
expect(configuration_from_file.to_h).to eq(config)
end
end
context 'when a file inherits from two configurations' do
let(:file_path) { '.rubocop.yml' }
before do
create_file('example.rb', '')
create_file('normal.yml',
['Metrics/MethodLength:',
' Enabled: false',
' CountComments: true',
' Max: 80'])
create_file('special.yml',
['Metrics/MethodLength:',
' Enabled: false',
' Max: 200'])
create_file(file_path,
['inherit_from:',
' - normal.yml',
' - special.yml',
'',
'Metrics/MethodLength:',
' Enabled: true'])
end
it 'returns values from the last one when possible' do
expected = { 'Enabled' => true, # overridden in .rubocop.yml
'CountComments' => true, # only defined in normal.yml
'Max' => 200 } # special.yml takes precedence
expect(configuration_from_file['Metrics/MethodLength'].to_set)
.to be_superset(expected.to_set)
end
end
context 'when a file inherits and overrides with non-namedspaced cops' do
let(:file_path) { '.rubocop.yml' }
before do
create_file('example.rb', '')
create_file('line_length.yml',
['LineLength:',
' Max: 120'])
create_file(file_path,
['inherit_from:',
' - line_length.yml',
'',
'LineLength:',
' AllowHeredoc: false'])
end
it 'returns includes both of the cop changes' do
config =
default_config.merge(
'Metrics/LineLength' => {
'Description' =>
default_config['Metrics/LineLength']['Description'],
'StyleGuide' => '#80-character-limits',
'Enabled' => true,
'Max' => 120, # overridden in line_length.yml
'AllowHeredoc' => false, # overridden in rubocop.yml
'AllowURI' => true,
'URISchemes' => %w[http https],
'IgnoreCopDirectives' => false,
'IgnoredPatterns' => []
}
)
expect(configuration_from_file.to_h).to eq(config)
end
end
context 'when a file inherits from an expanded path' do
let(:file_path) { '.rubocop.yml' }
before do
create_file('~/.rubocop.yml', [''])
create_file(file_path, ['inherit_from: ~/.rubocop.yml'])
end
it 'does not fail to load expanded path' do
expect { configuration_from_file }.not_to raise_error
end
end
context 'when a file inherits from an unknown gem' do
let(:file_path) { '.rubocop.yml' }
before do
create_file(file_path,
['inherit_gem:',
' not_a_real_gem: config/rubocop.yml'])
end
it 'fails to load' do
expect { configuration_from_file }.to raise_error(Gem::LoadError)
end
end
context 'when a file inherits from the rubocop gem' do
let(:file_path) { '.rubocop.yml' }
before do
create_file(file_path,
['inherit_gem:',
' rubocop: config/default.yml'])
end
it 'fails to load' do
expect { configuration_from_file }.to raise_error(ArgumentError)
end
end
context 'when a file inherits from a known gem' do
let(:file_path) { '.rubocop.yml' }
before do
create_file('gemone/config/rubocop.yml',
['Metrics/MethodLength:',
' Enabled: false',
' Max: 200',
' CountComments: false'])
create_file('gemtwo/config/default.yml',
['Metrics/LineLength:',
' Enabled: true'])
create_file('gemtwo/config/strict.yml',
['Metrics/LineLength:',
' Max: 72',
' AllowHeredoc: false'])
create_file('local.yml',
['Metrics/MethodLength:',
' CountComments: true'])
create_file(file_path,
['inherit_gem:',
' gemone: config/rubocop.yml',
' gemtwo:',
' - config/default.yml',
' - config/strict.yml',
'',
'inherit_from: local.yml',
'',
'Metrics/MethodLength:',
' Enabled: true',
'',
'Metrics/LineLength:',
' AllowURI: false'])
end
it 'returns values from the gem config with local overrides' do
gem_class = Struct.new(:gem_dir)
%w[gemone gemtwo].each do |gem_name|
mock_spec = gem_class.new(gem_name)
expect(Gem::Specification).to receive(:find_by_name)
.at_least(:once).with(gem_name).and_return(mock_spec)
end
expected = { 'Enabled' => true, # overridden in .rubocop.yml
'CountComments' => true, # overridden in local.yml
'Max' => 200 } # inherited from somegem
expect(configuration_from_file['Metrics/MethodLength'].to_set)
.to be_superset(expected.to_set)
expected = { 'Enabled' => true, # gemtwo/config/default.yml
'Max' => 72, # gemtwo/config/strict.yml
'AllowHeredoc' => false, # gemtwo/config/strict.yml
'AllowURI' => false } # overridden in .rubocop.yml
expect(configuration_from_file['Metrics/LineLength'].to_set)
.to be_superset(expected.to_set)
end
end
context 'when a file inherits from a url' do
let(:file_path) { '.rubocop.yml' }
let(:cache_file) { '.rubocop-http---example-com-rubocop-yml' }
before do
stub_request(:get, /example.com/)
.to_return(status: 200, body: "Style/Encoding:\n Enabled: true")
create_file(file_path, ['inherit_from: http://example.com/rubocop.yml'])
end
after do
File.unlink cache_file if File.exist? cache_file
end
it 'creates the cached file alongside the owning file' do
configuration_from_file
expect(File.exist?(cache_file)).to be true
end
end
context 'when a file inherits from a non http/https url' do
let(:file_path) { '.rubocop.yml' }
before do
create_file(file_path, ['inherit_from: c:\\\\foo\\bar.yml'])
end
it 'fails to load the resulting path' do
expect { configuration_from_file }.to raise_error(Errno::ENOENT)
end
end
context 'EnabledByDefault / DisabledByDefault' do
def cop_enabled?(cop_class)
configuration_from_file.for_cop(cop_class).fetch('Enabled')
end
let(:file_path) { '.rubocop.yml' }
before do
create_file(file_path, config)
end
context 'when DisabledByDefault is true' do
let(:config) do
['AllCops:',
' DisabledByDefault: true',
'Style/Copyright:',
' Exclude:',
' - foo']
end
it 'enables cops that are explicitly in the config file '\
'even if they are disabled by default' do
cop_class = RuboCop::Cop::Style::Copyright
expect(cop_enabled?(cop_class)).to be true
end
it 'disables cops that are normally enabled by default' do
cop_class = RuboCop::Cop::Style::TrailingWhitespace
expect(cop_enabled?(cop_class)).to be false
end
end
context 'when EnabledByDefault is true' do
let(:config) do
['AllCops:',
' EnabledByDefault: true',
'Style/TrailingWhitespace:',
' Enabled: false']
end
it 'enables cops that are disabled by default' do
cop_class = RuboCop::Cop::Style::FirstMethodArgumentLineBreak
expect(cop_enabled?(cop_class)).to be true
end
it 'respects cops that are disbled in the config' do
cop_class = RuboCop::Cop::Style::TrailingWhitespace
expect(cop_enabled?(cop_class)).to be false
end
end
end
end
describe '.load_file', :isolated_environment do
subject(:load_file) do
described_class.load_file(configuration_path)
end
let(:configuration_path) { '.rubocop.yml' }
it 'returns a configuration loaded from the passed path' do
create_file(configuration_path, [
'Style/Encoding:',
' Enabled: true'
])
configuration = load_file
expect(configuration['Style/Encoding']).to eq(
'Enabled' => true
)
end
it 'fails with a TypeError when loading a malformed configuration file' do
create_file(configuration_path, 'This string is not a YAML hash')
expect { load_file }.to raise_error(
TypeError, /^Malformed configuration in .*\.rubocop\.yml$/
)
end
it 'changes target ruby version with a patch to float' do
create_file(configuration_path, ['AllCops:',
' TargetRubyVersion: 2.3.4'])
expect(load_file.to_h).to eq('AllCops' => { 'TargetRubyVersion' => 2.3 })
end
it 'loads configuration properly when it includes non-ascii characters ' do
create_file(configuration_path, ['# All these cops of mine are ❤',
'Style/Encoding:',
' Enabled: false'])
expect(load_file.to_h).to eq('Style/Encoding' => { 'Enabled' => false })
end
it 'returns an empty configuration loaded from an empty file' do
create_file(configuration_path, '')
configuration = load_file
expect(configuration.to_h).to eq({})
end
context 'when SafeYAML is required' do
before do
create_file(configuration_path, [
'Style/WordArray:',
" WordRegex: !ruby/regexp '/\\A[\\p{Word}]+\\z/'"
])
end
context 'when it is fully required' do
it 'de-serializes Regexp class' do
in_its_own_process_with('safe_yaml') do
configuration = described_class.load_file('.rubocop.yml')
word_regexp = configuration['Style/WordArray']['WordRegex']
expect(word_regexp).to be_a(::Regexp)
end
end
end
context 'when safe_yaml is required without monkey patching' do
it 'de-serializes Regexp class' do
in_its_own_process_with('safe_yaml/load') do
configuration = described_class.load_file('.rubocop.yml')
word_regexp = configuration['Style/WordArray']['WordRegex']
expect(word_regexp).to be_a(::Regexp)
end
end
context 'and SafeYAML.load is private' do
# According to issue #2935, SafeYAML.load can be private in some
# circumstances.
it 'does not raise private method load called for SafeYAML:Module' do
in_its_own_process_with('safe_yaml/load') do
SafeYAML.send :private_class_method, :load
configuration = described_class.load_file('.rubocop.yml')
word_regexp = configuration['Style/WordArray']['WordRegex']
expect(word_regexp).to be_a(::Regexp)
end
end
end
end
end
end
describe '.merge' do
subject(:merge) { described_class.merge(base, derived) }
let(:base) do
{
'AllCops' => {
'Include' => ['**/*.gemspec', '**/Rakefile'],
'Exclude' => []
}
}
end
let(:derived) do
{ 'AllCops' => { 'Exclude' => ['example.rb', 'exclude_*'] } }
end
it 'returns a recursive merge of its two arguments' do
expect(merge).to eq('AllCops' => {
'Include' => ['**/*.gemspec', '**/Rakefile'],
'Exclude' => ['example.rb', 'exclude_*']
})
end
end
describe 'configuration for CharacterLiteral', :isolated_environment do
let(:dir_path) { 'test/blargh' }
let(:config) do
config_path = described_class.configuration_file_for(dir_path)
described_class.configuration_from_file(config_path)
end
context 'when .rubocop.yml inherits from a file with a name starting ' \
'with .rubocop' do
before do
create_file('test/.rubocop_rules.yml', ['Style/CharacterLiteral:',
' Exclude:',
' - blargh/blah.rb'])
create_file('test/.rubocop.yml', 'inherit_from: .rubocop_rules.yml')
end
it 'gets an Exclude relative to the inherited file converted to ' \
'absolute' do
expect(config.for_cop(RuboCop::Cop::Style::CharacterLiteral)['Exclude'])
.to eq([File.join(Dir.pwd, 'test/blargh/blah.rb')])
end
end
end
describe 'configuration for AssignmentInCondition' do
describe 'AllowSafeAssignment' do
it 'is enabled by default' do
default_config = described_class.default_configuration
symbol_name_config =
default_config.for_cop('Lint/AssignmentInCondition')
expect(symbol_name_config['AllowSafeAssignment']).to be_truthy
end
end
end
describe 'when a requirement is defined', :isolated_environment do
let(:required_file_path) { './required_file.rb' }
before do
create_file('.rubocop.yml', ['require:', " - #{required_file_path}"])
create_file(required_file_path, ['class MyClass', 'end'])
end
it 'requires the passed path' do
config_path = described_class.configuration_file_for('.')
described_class.configuration_from_file(config_path)
expect(defined?(MyClass)).to be_truthy
end
it 'uses paths relative to the .rubocop.yml, not cwd' do
config_path = described_class.configuration_file_for('.')
Dir.chdir '..' do
described_class.configuration_from_file(config_path)
expect(defined?(MyClass)).to be_truthy
end
end
end
describe 'when a unqualified requirement is defined', :isolated_environment do
let(:required_file_path) { 'required_file' }
before do
create_file('.rubocop.yml', ['require:', " - #{required_file_path}"])
create_file(required_file_path + '.rb', ['class MyClass', 'end'])
end
it 'works without a starting .' do
config_path = described_class.configuration_file_for('.')
$LOAD_PATH.unshift(File.dirname(config_path))
Dir.chdir '..' do
described_class.configuration_from_file(config_path)
expect(defined?(MyClass)).to be_truthy
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/config_spec.rb 0000664 0000000 0000000 00000047052 13070542236 0022354 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Config do
include FileHelper
subject(:configuration) { described_class.new(hash, loaded_path) }
let(:hash) { {} }
let(:loaded_path) { 'example/.rubocop.yml' }
describe '#validate', :isolated_environment do
subject(:configuration) do
RuboCop::ConfigLoader.load_file(configuration_path)
end
let(:configuration_path) { '.rubocop.yml' }
context 'when the configuration includes any unrecognized cop name' do
before do
create_file(configuration_path, [
'LyneLenth:',
' Enabled: true',
' Max: 100'
])
$stderr = StringIO.new
end
after do
$stderr = STDERR
end
it 'prints a warning message' do
configuration # ConfigLoader.load_file will validate config
expect($stderr.string).to match(/unrecognized cop LyneLenth/)
end
end
context 'when the configuration includes an empty section' do
before do
create_file(configuration_path, ['Metrics/LineLength:'])
end
it 'raises validation error' do
expect { configuration.validate }
.to raise_error(RuboCop::ValidationError,
%r{^empty section Metrics/LineLength})
end
end
context 'when the empty section is AllCops' do
before do
create_file(configuration_path, ['AllCops:'])
end
it 'raises validation error' do
expect { configuration.validate }
.to raise_error(RuboCop::ValidationError, /^empty section AllCops/)
end
end
context 'when the configuration is in the base RuboCop config folder' do
before do
create_file(configuration_path, [
'InvalidProperty:',
' Enabled: true'
])
stub_const('RuboCop::ConfigLoader::RUBOCOP_HOME', rubocop_home_path)
end
let(:rubocop_home_path) { File.realpath('.') }
let(:configuration_path) { 'config/.rubocop.yml' }
it 'is not validated' do
expect { configuration.validate }.not_to raise_error
end
end
context 'when the configuration includes any unrecognized parameter' do
before do
create_file(configuration_path, [
'Metrics/LineLength:',
' Enabled: true',
' Min: 10'
])
$stderr = StringIO.new
end
after do
$stderr = STDERR
end
it 'prints a warning message' do
configuration # ConfigLoader.load_file will validate config
expect($stderr.string).to match(
%r{unrecognized parameter Metrics/LineLength:Min}
)
end
end
context 'when the configuration includes any common parameter' do
# Common parameters are parameters that are not in the default
# configuration, but are nonetheless allowed for any cop.
before do
create_file(configuration_path, [
'Metrics/ModuleLength:',
' Exclude:',
' - lib/file.rb',
' Include:',
' - lib/file.xyz',
' Severity: warning',
' StyleGuide: https://example.com/some-style.html'
])
end
it 'does not raise validation error' do
expect { configuration.validate }.not_to raise_error
end
end
context 'when the configuration includes a valid EnforcedStyle' do
before do
create_file(configuration_path, [
'Style/AndOr:',
' EnforcedStyle: conditionals'
])
end
it 'does not raise validation error' do
expect { configuration.validate }.not_to raise_error
end
end
context 'when the configration includes an invalid EnforcedStyle' do
before do
create_file(configuration_path, [
'Style/AndOr:',
' EnforcedStyle: itisinvalid'
])
end
it 'raises validation error' do
expect { configuration.validate }
.to raise_error(RuboCop::ValidationError, /itisinvalid/)
end
end
context 'when the configration includes a valid Enforced.+Style' do
before do
create_file(configuration_path, [
'Style/SpaceAroundBlockParameters:',
' EnforcedStyleInsidePipes: space'
])
end
it 'does not raise validation error' do
expect { configuration.validate }.not_to raise_error
end
end
context 'when the configration includes an invalid Enforced.+Style' do
before do
create_file(configuration_path, [
'Style/SpaceAroundBlockParameters:',
' EnforcedStyleInsidePipes: itisinvalid'
])
end
it 'raises validation error' do
expect { configuration.validate }
.to raise_error(RuboCop::ValidationError, /itisinvalid/)
end
end
context 'when the configuration includes an obsolete cop' do
before do
create_file(configuration_path, [
'Style/MethodCallParentheses:',
' Enabled: true'
])
end
it 'raises validation error' do
expect { configuration.validate }
.to raise_error(RuboCop::ValidationError,
%r{Style/MethodCallWithoutArgsParentheses})
end
end
context 'when the configuration includes an obsolete parameter' do
before do
create_file(configuration_path, [
'Rails/UniqBeforePluck:',
' EnforcedMode: conservative'
])
end
it 'raises validation error' do
expect { configuration.validate }
.to raise_error(RuboCop::ValidationError, /EnforcedStyle/)
end
end
context 'when the configuration includes obsolete parameters and cops' do
before do
create_file(configuration_path, [
'Rails/UniqBeforePluck:',
' EnforcedMode: conservative',
'Style/MethodCallParentheses:',
' Enabled: false',
'Lint/BlockAlignment:',
' AlignWith: either',
'Style/SpaceBeforeModifierKeyword:',
' Enabled: false'
])
end
it 'raises validation error' do
message_matcher = lambda do |message|
message.include?('EnforcedStyle') &&
message.include?('MethodCallWithoutArgsParentheses') &&
message.include?('EnforcedStyleAlignWith') &&
message.include?('Style/SpaceAroundKeyword')
end
expect { configuration.validate }
.to raise_error(RuboCop::ValidationError, message_matcher)
end
end
context 'when all cops are both Enabled and Disabled by default' do
before do
create_file(configuration_path, [
'AllCops:',
' EnabledByDefault: true',
' DisabledByDefault: true'
])
end
it 'raises validation error' do
expect { configuration.validate }
.to raise_error(
RuboCop::ValidationError,
/Cops cannot be both enabled by default and disabled by default/
)
end
end
end
describe '#make_excludes_absolute' do
context 'when config is in root directory' do
let(:hash) do
{
'AllCops' => {
'Exclude' => [
'config/environment',
'spec'
]
}
}
end
before do
allow(configuration)
.to receive(:base_dir_for_path_parameters)
.and_return('/home/foo/project')
configuration.make_excludes_absolute
end
it 'generates valid absolute directory' do
excludes = configuration['AllCops']['Exclude']
.map { |e| e.sub(/^[A-Z]:/, '') }
expect(excludes)
.to eq [
'/home/foo/project/config/environment',
'/home/foo/project/spec'
]
end
end
context 'when config is in subdirectory' do
let(:hash) do
{
'AllCops' => {
'Exclude' => [
'../../config/environment',
'../../spec'
]
}
}
end
before do
allow(configuration)
.to receive(:base_dir_for_path_parameters)
.and_return('/home/foo/project/config/tools')
configuration.make_excludes_absolute
end
it 'generates valid absolute directory' do
excludes = configuration['AllCops']['Exclude']
.map { |e| e.sub(/^[A-Z]:/, '') }
expect(excludes)
.to eq [
'/home/foo/project/config/environment',
'/home/foo/project/spec'
]
end
end
end
describe '#file_to_include?' do
let(:hash) do
{
'AllCops' => {
'Include' => ['**/Gemfile', 'config/unicorn.rb.example']
}
}
end
let(:loaded_path) { '/home/foo/project/.rubocop.yml' }
context 'when the passed path matches any of patterns to include' do
it 'returns true' do
file_path = '/home/foo/project/Gemfile'
expect(configuration.file_to_include?(file_path)).to be_truthy
end
end
context 'when the passed path does not match any of patterns to include' do
it 'returns false' do
file_path = '/home/foo/project/Gemfile.lock'
expect(configuration.file_to_include?(file_path)).to be_falsey
end
end
end
describe '#file_to_exclude?' do
before { $stderr = StringIO.new }
after { $stderr = STDERR }
let(:hash) do
{
'AllCops' => {
'Exclude' => [
"#{Dir.pwd}/log/**/*",
'**/bar.rb'
]
}
}
end
let(:loaded_path) { '/home/foo/project/.rubocop.yml' }
context 'when the passed path matches any of patterns to exclude' do
it 'returns true' do
file_path = "#{Dir.pwd}/log/foo.rb"
expect(configuration.file_to_exclude?(file_path)).to be_truthy
expect(configuration.file_to_exclude?('log/foo.rb')).to be_truthy
expect(configuration.file_to_exclude?('bar.rb')).to be_truthy
end
end
context 'when the passed path does not match any of patterns to exclude' do
it 'returns false' do
file_path = "#{Dir.pwd}/log_file.rb"
expect(configuration.file_to_exclude?(file_path)).to be_falsey
expect(configuration.file_to_exclude?('app/controller.rb')).to be_falsey
expect(configuration.file_to_exclude?('baz.rb')).to be_falsey
end
end
end
describe '#patterns_to_include' do
subject(:patterns_to_include) do
configuration = described_class.new(hash, loaded_path)
configuration.patterns_to_include
end
let(:loaded_path) { 'example/.rubocop.yml' }
context 'when config file has AllCops => Include key' do
let(:hash) do
{
'AllCops' => {
'Include' => ['**/Gemfile', 'config/unicorn.rb.example']
}
}
end
it 'returns the Include value' do
expect(patterns_to_include).to eq([
'**/Gemfile',
'config/unicorn.rb.example'
])
end
end
end
describe '#possibly_include_hidden?' do
subject(:configuration) do
described_class.new(hash, loaded_path)
end
let(:loaded_path) { 'example/.rubocop.yml' }
it 'returns true when Include config only includes regular paths' do
configuration['AllCops'] = {
'Include' => ['**/Gemfile', 'config/unicorn.rb.example']
}
expect(configuration.possibly_include_hidden?).to be(false)
end
it 'returns true when Include config includes a regex' do
configuration['AllCops'] = { 'Include' => [/foo/] }
expect(configuration.possibly_include_hidden?).to be(true)
end
it 'returns true when Include config includes a toplevel dotfile' do
configuration['AllCops'] = { 'Include' => ['.foo'] }
expect(configuration.possibly_include_hidden?).to be(true)
end
it 'returns true when Include config includes a dotfile in a path' do
configuration['AllCops'] = { 'Include' => ['foo/.bar'] }
expect(configuration.possibly_include_hidden?).to be(true)
end
end
describe '#patterns_to_exclude' do
subject(:patterns_to_exclude) do
configuration = described_class.new(hash, loaded_path)
configuration.patterns_to_exclude
end
let(:loaded_path) { 'example/.rubocop.yml' }
context 'when config file has AllCops => Exclude key' do
let(:hash) do
{
'AllCops' => {
'Exclude' => ['log/*']
}
}
end
it 'returns the Exclude value' do
expect(patterns_to_exclude).to eq(['log/*'])
end
end
end
describe '#deprecation_check' do
context 'when there is no AllCops configuration' do
let(:hash) { {} }
it 'does not yield' do
expect { |b| configuration.deprecation_check(&b) }.not_to yield_control
end
end
context 'when there is AllCops configuration' do
context 'if there are no Excludes or Includes keys' do
let(:hash) { { 'AllCops' => { 'Exclude' => [], 'Include' => [] } } }
it 'does not yield' do
expect do |b|
configuration.deprecation_check(&b)
end.not_to yield_control
end
end
context 'if there are is an Includes key' do
let(:hash) { { 'AllCops' => { 'Includes' => [] } } }
it 'yields' do
expect do |b|
configuration.deprecation_check(&b)
end.to yield_with_args(String)
end
end
context 'if there are is an Excludes key' do
let(:hash) { { 'AllCops' => { 'Excludes' => [] } } }
it 'yields' do
expect do |b|
configuration.deprecation_check(&b)
end.to yield_with_args(String)
end
end
end
end
context 'whether the cop is enabled' do
def cop_enabled(cop_class)
configuration.for_cop(cop_class).fetch('Enabled')
end
context 'when an entire cop department is disabled' do
context 'but an individual cop is enabled' do
let(:hash) do
{
'Style' => { 'Enabled' => false },
'Style/TrailingWhitespace' => { 'Enabled' => true }
}
end
it 'still disables the cop' do
cop_class = RuboCop::Cop::Style::TrailingWhitespace
expect(cop_enabled(cop_class)).to be false
end
end
end
context 'when an entire cop department is enabled' do
context 'but an individual cop is disabled' do
let(:hash) do
{
'Style' => { 'Enabled' => true },
'Style/TrailingWhitespace' => { 'Enabled' => false }
}
end
it 'still disables the cop' do
cop_class = RuboCop::Cop::Style::TrailingWhitespace
expect(cop_enabled(cop_class)).to be false
end
end
end
context 'when a cop has configuration but no explicit Enabled setting' do
let(:hash) do
{
'Style/TrailingWhitespace' => { 'Exclude' => ['foo'] }
}
end
it 'enables the cop by default' do
cop_class = RuboCop::Cop::Style::TrailingWhitespace
expect(cop_enabled(cop_class)).to be true
end
end
end
describe '#target_rails_version' do
context 'when TargetRailsVersion is set' do
let(:rails_version) { 4.0 }
let(:hash) do
{
'AllCops' => {
'TargetRailsVersion' => rails_version
}
}
end
it 'uses TargetRailsVersion' do
expect(configuration.target_rails_version).to eq rails_version
end
end
context 'when TargetRailsVersion is not set' do
let(:hash) do
{
'AllCops' => {}
}
end
it 'uses the default rails version' do
default_version = RuboCop::Config::DEFAULT_RAILS_VERSION
expect(configuration.target_rails_version).to eq default_version
end
end
end
describe '#target_ruby_version' do
context 'when TargetRubyVersion is set' do
let(:ruby_version) { 2.1 }
let(:hash) do
{
'AllCops' => {
'TargetRubyVersion' => ruby_version
}
}
end
before do
allow(File).to receive(:file?).with('.ruby-version')
end
it 'uses TargetRubyVersion' do
expect(configuration.target_ruby_version).to eq ruby_version
end
it 'does not read .ruby-version' do
configuration.target_ruby_version
expect(File).not_to have_received(:file?).with('.ruby-version')
end
end
context 'when TargetRubyVersion is not set' do
context 'when .ruby-version is present' do
before do
allow(File).to receive(:file?).with('.ruby-version').and_return true
allow(File)
.to receive(:read)
.with('.ruby-version')
.and_return ruby_version
end
context 'when .ruby-version contains an MRI version' do
let(:ruby_version) { '2.2.4' }
let(:ruby_version_to_f) { 2.2 }
it 'reads it to determine the target ruby version' do
expect(configuration.target_ruby_version).to eq ruby_version_to_f
end
end
context 'when the MRI version contains multiple digits' do
let(:ruby_version) { '10.11.0' }
let(:ruby_version_to_f) { 10.11 }
it 'reads it to determine the target ruby version' do
expect(configuration.target_ruby_version).to eq ruby_version_to_f
end
end
context 'when .ruby-version contains a version prefixed by "ruby-"' do
let(:ruby_version) { 'ruby-2.3.0' }
let(:ruby_version_to_f) { 2.3 }
it 'correctly determines the target ruby version' do
expect(configuration.target_ruby_version).to eq ruby_version_to_f
end
end
context 'when .ruby-version contains a JRuby version' do
let(:ruby_version) { 'jruby-9.1.2.0' }
it 'uses the default target ruby version' do
expect(configuration.target_ruby_version)
.to eq described_class::DEFAULT_RUBY_VERSION
end
end
context 'when .ruby-version contains a Rbx version' do
let(:ruby_version) { 'rbx-3.42' }
it 'uses the default target ruby version' do
expect(configuration.target_ruby_version)
.to eq described_class::DEFAULT_RUBY_VERSION
end
end
context 'when .ruby-version contains "system" version' do
let(:ruby_version) { 'system' }
it 'uses the default target ruby version' do
expect(configuration.target_ruby_version)
.to eq described_class::DEFAULT_RUBY_VERSION
end
end
end
context 'when .ruby-version is not present' do
before do
allow(File).to receive(:file?).with('.ruby-version').and_return false
end
it 'uses the default target ruby version' do
expect(configuration.target_ruby_version)
.to eq described_class::DEFAULT_RUBY_VERSION
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/config_store_spec.rb 0000664 0000000 0000000 00000004503 13070542236 0023562 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::ConfigStore do
subject(:config_store) { described_class.new }
before do
allow(RuboCop::ConfigLoader).to receive(:configuration_file_for) do |arg|
# File tree:
# file1
# dir/.rubocop.yml
# dir/file2
# dir/subdir/file3
(arg =~ /dir/ ? 'dir' : '.') + '/.rubocop.yml'
end
allow(RuboCop::ConfigLoader)
.to receive(:configuration_from_file) { |arg| arg }
allow(RuboCop::ConfigLoader)
.to receive(:load_file) { |arg| RuboCop::Config.new(arg) }
allow(RuboCop::ConfigLoader)
.to receive(:merge_with_default) { |config| "merged #{config.to_h}" }
allow(RuboCop::ConfigLoader)
.to receive(:default_configuration) { 'default config' }
end
describe '.for' do
it 'always uses config specified in command line' do
config_store.options_config = { options_config: true }
expect(config_store.for('file1')).to eq('merged {:options_config=>true}')
end
context 'when no config specified in command line' do
it 'gets config path and config from cache if available' do
expect(RuboCop::ConfigLoader)
.to receive(:configuration_file_for).once.with('dir')
expect(RuboCop::ConfigLoader)
.to receive(:configuration_file_for).once.with('dir/subdir')
# The stub returns the same config path for dir and dir/subdir.
expect(RuboCop::ConfigLoader)
.to receive(:configuration_from_file).once.with('dir/.rubocop.yml')
config_store.for('dir/file2')
config_store.for('dir/file2')
config_store.for('dir/subdir/file3')
end
it 'searches for config path if not available in cache' do
expect(RuboCop::ConfigLoader).to receive(:configuration_file_for).once
expect(RuboCop::ConfigLoader).to receive(:configuration_from_file).once
config_store.for('file1')
end
context 'when --force-default-config option is specified' do
it 'uses default config without searching for config path' do
expect(RuboCop::ConfigLoader).not_to receive(:configuration_file_for)
expect(RuboCop::ConfigLoader).not_to receive(:configuration_from_file)
config_store.force_default_config!
expect(config_store.for('file1')).to eq('default config')
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/ 0000775 0000000 0000000 00000000000 13070542236 0020321 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/badge_spec.rb 0000664 0000000 0000000 00000002642 13070542236 0022726 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Badge do
subject(:badge) { described_class.new('Test', 'ModuleMustBeAClassCop') }
it 'exposes department name' do
expect(badge.department).to be(:Test)
end
it 'exposes cop name' do
expect(badge.cop_name).to eql('ModuleMustBeAClassCop')
end
describe '.parse' do
it 'parses Department/CopName syntax' do
expect(described_class.parse('Foo/Bar'))
.to eq(described_class.new('Foo', 'Bar'))
end
it 'parses unqualified badge references' do
expect(described_class.parse('Bar'))
.to eql(described_class.new(nil, 'Bar'))
end
end
describe '.for' do
it 'parses cop class name' do
expect(described_class.for('RuboCop::Cop::Foo::Bar'))
.to eq(described_class.new('Foo', 'Bar'))
end
end
it 'compares by value' do
badge1 = described_class.new('Foo', 'Bar')
badge2 = described_class.new('Foo', 'Bar')
expect(Set.new([badge1, badge2]).one?).to be(true)
end
it 'can be converted to a string with the Department/CopName format' do
expect(described_class.new('Foo', 'Bar').to_s).to eql('Foo/Bar')
end
describe '#qualified?' do
it 'says `CopName` is not qualified' do
expect(described_class.parse('Bar')).not_to be_qualified
end
it 'says `Department/CopName` is qualified' do
expect(described_class.parse('Department/Bar')).to be_qualified
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/bundler/ 0000775 0000000 0000000 00000000000 13070542236 0021754 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/bundler/duplicated_gem_spec.rb 0000664 0000000 0000000 00000004344 13070542236 0026266 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Bundler::DuplicatedGem, :config do
let(:cop_config) { { 'Include' => ['**/Gemfile'] } }
subject(:cop) { described_class.new(config) }
context 'when investigating Ruby files' do
let(:source) { <<-END }
# cop will not read these contents
gem('rubocop')
gem('rubocop')
END
it 'does not register any offenses' do
inspect_source_file(cop, source)
expect(cop.offenses).to be_empty
end
end
context 'when investigating Gemfiles' do
context 'and the file is empty' do
let(:source) { '' }
it 'does not raise an error' do
expect { inspect_source(cop, source, 'gems.rb') }.not_to raise_error
end
it 'does not register any offenses' do
expect(cop.offenses).to be_empty
end
end
context 'and no duplicate gems are present' do
let(:source) { <<-GEM }
gem 'rubocop'
gem 'flog'
GEM
it 'does not register any offenses' do
inspect_gemfile(cop, source)
expect(cop.offenses).to be_empty
end
end
context 'and a gem is duplicated in default group' do
let(:source) { <<-GEM }
source 'https://rubygems.org'
gem 'rubocop'
gem 'rubocop'
GEM
it 'registers an offense' do
inspect_gemfile(cop, source)
expect(cop.offenses.size).to eq(1)
end
it "references gem's first occurance in message" do
inspect_gemfile(cop, source)
expect(cop.offenses.first.message).to include('2')
end
it 'highlights the duplicate gem' do
inspect_gemfile(cop, source)
expect(cop.highlights).to eq(["gem 'rubocop'"])
end
end
context 'and a duplicated gem is in a git/path/group/platforms block' do
let(:source) { <<-GEM }
gem 'rubocop'
group :development do
gem 'rubocop', path: '/path/to/gem'
end
GEM
it 'registers an offense' do
inspect_gemfile(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'highlights the duplicate gem' do
inspect_gemfile(cop, source)
expect(cop.highlights).to eq(["gem 'rubocop', path: '/path/to/gem'"])
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/bundler/ordered_gems_spec.rb 0000664 0000000 0000000 00000015364 13070542236 0025763 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Bundler::OrderedGems, :config do
let(:cop_config) do
{
'TreatCommentsAsGroupSeparators' => treat_comments_as_group_separators,
'Include' => nil
}
end
let(:treat_comments_as_group_separators) { false }
subject(:cop) { described_class.new(config) }
context 'When gems are alphabetically sorted' do
let(:source) { <<-END }
gem 'rspec'
gem 'rubocop'
END
it 'does not register any offenses' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
context 'When gems are not alphabetically sorted' do
let(:source) { <<-END }
gem 'rubocop'
gem 'rspec'
END
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'has the correct offense message' do
inspect_source(cop, source)
expect(cop.messages)
.to eq(['Gems should be sorted in an alphabetical ' \
'order within their section of the Gemfile. ' \
'Gem `rspec` should appear before `rubocop`.'])
end
it 'highlights the second gem' do
inspect_source(cop, source)
expect(cop.highlights).to eq(["gem 'rspec'"])
end
it 'autocorrects' do
new_source = autocorrect_source_with_loop(cop, source)
expect(new_source).to eq([" gem 'rspec'",
" gem 'rubocop'",
''].join("\n"))
end
end
context 'When each individual group of line is sorted' do
let(:source) { <<-END }
gem 'rspec'
gem 'rubocop'
gem 'hello'
gem 'world'
END
it 'does not register any offenses' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
context 'When a gem declaration takes several lines' do
let(:source) { <<-END }
gem 'rubocop',
'0.1.1'
gem 'rspec'
END
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'autocorrects' do
new_source = autocorrect_source_with_loop(cop, source)
expect(new_source).to eq([" gem 'rspec'",
" gem 'rubocop',",
" '0.1.1'",
''].join("\n"))
end
end
context 'When the gemfile is empty' do
let(:source) { <<-END }
# Gemfile
END
it 'does not register any offenses' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(0)
end
end
context 'When each individual group of line is not sorted' do
let(:source) { <<-END }
gem "d"
gem "b"
gem "e"
gem "a"
gem "c"
gem "h"
gem "g"
gem "j"
gem "f"
gem "i"
END
it 'registers some offenses' do
inspect_source(cop, source)
expect(cop.offenses).not_to be_empty
end
it 'autocorrects' do
new_source = autocorrect_source_with_loop(cop, source)
expect(new_source).to eq([' gem "a"',
' gem "b"',
' gem "c"',
' gem "d"',
' gem "e"',
'',
' gem "f"',
' gem "g"',
' gem "h"',
' gem "i"',
' gem "j"',
''].join("\n"))
end
end
context 'When gem groups is separated by multiline comment' do
let(:source) { <<-END }
# For code quality
gem 'rubocop'
# For
# test
gem 'rspec'
END
context 'with TreatCommentsAsGroupSeparators: true' do
let(:treat_comments_as_group_separators) { true }
it 'accepts' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
context 'with TreatCommentsAsGroupSeparators: false' do
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'has the correct offense message' do
inspect_source(cop, source)
expect(cop.messages)
.to eq(['Gems should be sorted in an alphabetical ' \
'order within their section of the Gemfile. ' \
'Gem `rspec` should appear before `rubocop`.'])
end
it 'highlights the second gem' do
inspect_source(cop, source)
expect(cop.highlights).to eq(["gem 'rspec'"])
end
it 'autocorrects' do
new_source = autocorrect_source_with_loop(cop, source)
expect(new_source).to eq([' # For',
' # test',
" gem 'rspec'",
' # For code quality',
" gem 'rubocop'",
''].join("\n"))
end
end
end
context 'When gems have an inline comment, and not sorted' do
let(:source) { <<-END }
gem 'rubocop' # For code quality
gem 'pry'
gem 'rspec' # For test
END
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'autocorrects' do
new_source = autocorrect_source_with_loop(cop, source)
expect(new_source).to eq([" gem 'pry'",
" gem 'rspec' # For test",
" gem 'rubocop' # For code quality",
''].join("\n"))
end
end
context 'When gems are asciibetically sorted' do
let(:source) { <<-END }
gem 'paper_trail'
gem 'paperclip'
END
it 'does not register an offense' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
context 'When a gem that starts with a capital letter is sorted' do
let(:source) { <<-END }
gem 'a'
gem 'Z'
END
it 'does not register an offense' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
context 'When a gem that starts with a capital letter is not sorted' do
let(:source) { <<-END }
gem 'Z'
gem 'a'
END
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'autocorrects' do
new_source = autocorrect_source_with_loop(cop, source)
expect(new_source).to eq([" gem 'a'",
" gem 'Z'",
''].join("\n"))
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/commissioner_spec.rb 0000664 0000000 0000000 00000005557 13070542236 0024403 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Commissioner do
describe '#investigate' do
let(:cop) do
double(RuboCop::Cop, offenses: [], excluded_file?: false).as_null_object
end
let(:force) { double(RuboCop::Cop::Force).as_null_object }
it 'returns all offenses found by the cops' do
allow(cop).to receive(:offenses).and_return([1])
commissioner = described_class.new([cop], [])
source = []
processed_source = parse_source(source)
expect(commissioner.investigate(processed_source)).to eq [1]
end
context 'when a cop has no interest in the file' do
it 'returns all offenses except the ones of the cop' do
cops = []
cops << double('cop A', offenses: %w[foo], excluded_file?: false)
cops << double('cop B', excluded_file?: true)
cops << double('cop C', offenses: %w[baz], excluded_file?: false)
cops.each(&:as_null_object)
commissioner = described_class.new(cops, [])
source = []
processed_source = parse_source(source)
expect(commissioner.investigate(processed_source)).to eq %w[foo baz]
end
end
it 'traverses the AST and invoke cops specific callbacks' do
expect(cop).to receive(:on_def)
commissioner = described_class.new([cop], [])
source = ['def method', '1', 'end']
processed_source = parse_source(source)
commissioner.investigate(processed_source)
end
it 'passes the input params to all cops/forces that implement their own' \
' #investigate method' do
source = []
processed_source = parse_source(source)
expect(cop).to receive(:investigate).with(processed_source)
expect(force).to receive(:investigate).with(processed_source)
commissioner = described_class.new([cop], [force])
commissioner.investigate(processed_source)
end
it 'stores all errors raised by the cops' do
allow(cop).to receive(:on_int) { raise RuntimeError }
commissioner = described_class.new([cop], [])
source = ['def method', '1', 'end']
processed_source = parse_source(source)
commissioner.investigate(processed_source)
expect(commissioner.errors[cop].size).to eq(1)
expect(commissioner.errors[cop][0].error).to be_instance_of(RuntimeError)
expect(commissioner.errors[cop][0].line).to eq 2
expect(commissioner.errors[cop][0].column).to eq 0
end
context 'when passed :raise_error option' do
it 're-raises the exception received while processing' do
allow(cop).to receive(:on_int) { raise RuntimeError }
commissioner = described_class.new([cop], [], raise_error: true)
source = ['def method', '1', 'end']
processed_source = parse_source(source)
expect do
commissioner.investigate(processed_source)
end.to raise_error(RuntimeError)
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/cop_spec.rb 0000664 0000000 0000000 00000016432 13070542236 0022447 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Cop do
subject(:cop) { described_class.new }
let(:location) do
source_buffer = Parser::Source::Buffer.new('test', 1)
source_buffer.source = "a\n"
Parser::Source::Range.new(source_buffer, 0, 1)
end
it 'initially has 0 offenses' do
expect(cop.offenses).to be_empty
end
describe '.qualified_cop_name' do
before do
$stderr = StringIO.new
end
after do
$stderr = STDERR
end
it 'adds namespace if the cop name is found in exactly one namespace' do
expect(described_class.qualified_cop_name('LineLength', '--only'))
.to eq('Metrics/LineLength')
end
it 'returns the given cop name if it is not found in any namespace' do
expect(described_class.qualified_cop_name('UnknownCop', '--only'))
.to eq('UnknownCop')
end
it 'returns the given cop name if it already has a namespace' do
expect(described_class.qualified_cop_name('Metrics/LineLength', '--only'))
.to eq('Metrics/LineLength')
end
it 'returns the cop name in a different namespace if the provided ' \
'namespace is incorrect' do
expect(described_class.qualified_cop_name('Style/LineLength', '--only'))
.to eq('Metrics/LineLength')
end
it 'raises an error if the cop name is in more than one namespace' do
expect { described_class.qualified_cop_name('SafeNavigation', '--only') }
.to raise_error(RuboCop::Cop::AmbiguousCopName)
end
it 'returns the given cop name if it already has a namespace even when ' \
'the cop exists in multiple namespaces' do
qualified_cop_name =
described_class.qualified_cop_name('Style/SafeNavigation', '--only')
expect(qualified_cop_name).to eq('Style/SafeNavigation')
end
end
it 'keeps track of offenses' do
cop.add_offense(nil, location, 'message')
expect(cop.offenses.size).to eq(1)
end
it 'will report registered offenses' do
cop.add_offense(nil, location, 'message')
expect(cop.offenses).not_to be_empty
end
it 'will set default severity' do
cop.add_offense(nil, location, 'message')
expect(cop.offenses.first.severity).to eq(:convention)
end
it 'will set custom severity if present' do
cop.config[cop.name] = { 'Severity' => 'warning' }
cop.add_offense(nil, location, 'message')
expect(cop.offenses.first.severity).to eq(:warning)
end
it 'will warn if custom severity is invalid' do
cop.config[cop.name] = { 'Severity' => 'superbad' }
expect(cop).to receive(:warn)
cop.add_offense(nil, location, 'message')
end
it 'registers offense with its name' do
cop = RuboCop::Cop::Style::For.new
cop.add_offense(nil, location, 'message')
expect(cop.offenses.first.cop_name).to eq('Style/For')
end
describe 'setting of Offense#corrected attribute' do
context 'when cop does not support autocorrection' do
before do
allow(cop).to receive(:support_autocorrect?).and_return(false)
end
it 'is not specified (set to nil)' do
cop.add_offense(nil, location, 'message')
expect(cop.offenses.first.corrected?).to be(false)
end
end
context 'when cop supports autocorrection' do
let(:cop) { RuboCop::Cop::Style::Alias.new }
context 'when offense was corrected' do
before do
allow(cop).to receive(:autocorrect?).and_return(true)
allow(cop).to receive(:autocorrect).and_return(->(_corrector) {})
end
it 'is set to true' do
cop.add_offense(nil, location, 'message')
expect(cop.offenses.first.corrected?).to eq(true)
end
end
context 'when autocorrection is not needed' do
before do
allow(cop).to receive(:autocorrect?).and_return(false)
end
it 'is set to false' do
cop.add_offense(nil, location, 'message')
expect(cop.offenses.first.corrected?).to eq(false)
end
end
context 'when offense was not corrected because of an error' do
before do
allow(cop).to receive(:autocorrect?).and_return(true)
allow(cop).to receive(:autocorrect).and_return(false)
end
it 'is set to false' do
cop.add_offense(nil, location, 'message')
expect(cop.offenses.first.corrected?).to eq(false)
end
end
end
end
context 'with no submodule' do
subject(:cop) { described_class }
it('has right name') { expect(cop.cop_name).to eq('Cop/Cop') }
it('has right department') { expect(cop.department).to eq(:Cop) }
end
context 'with style cops' do
subject(:cop) { RuboCop::Cop::Style::For }
it('has right name') { expect(cop.cop_name).to eq('Style/For') }
it('has right department') { expect(cop.department).to eq(:Style) }
end
context 'with lint cops' do
subject(:cop) { RuboCop::Cop::Lint::Loop }
it('has right name') { expect(cop.cop_name).to eq('Lint/Loop') }
it('has right department') { expect(cop.department).to eq(:Lint) }
end
context 'with rails cops' do
subject(:cop) { RuboCop::Cop::Rails::Validation }
it('has right name') { expect(cop.cop_name).to eq('Rails/Validation') }
it('has right department') { expect(cop.department).to eq(:Rails) }
end
describe 'Registry' do
context '#departments' do
subject(:departments) { described_class.registry.departments }
it('has departments') { expect(departments.length).not_to eq(0) }
it { is_expected.to include(:Lint) }
it { is_expected.to include(:Rails) }
it { is_expected.to include(:Style) }
it 'contains every value only once' do
expect(departments.length).to eq(departments.uniq.length)
end
end
context '#with_department' do
let(:departments) { described_class.registry.departments }
it 'has at least one cop per department' do
departments.each do |c|
expect(described_class.registry.with_department(c).length).to be > 0
end
end
it 'has each cop in exactly one type' do
sum = 0
departments.each do |c|
sum += described_class.registry.with_department(c).length
end
expect(sum).to be described_class.registry.length
end
it 'returns 0 for an invalid type' do
expect(described_class.registry.with_department('x').length).to be 0
end
end
end
describe '#autocorrect?' do
# dummy config for a generic cop instance
let(:config) { RuboCop::Config.new({}) }
let(:cop) { described_class.new(config, options) }
let(:support_autocorrect) { true }
subject { cop.autocorrect? }
before do
allow(cop).to receive(:support_autocorrect?) { support_autocorrect }
end
context 'when the option is not given' do
let(:options) { {} }
it { is_expected.to be(false) }
end
context 'when the option is given' do
let(:options) { { auto_correct: true } }
it { is_expected.to be(true) }
context 'when cop does not support autocorrection' do
let(:support_autocorrect) { false }
it { is_expected.to be(false) }
end
context 'when the cop is set to not autocorrect' do
let(:config) do
RuboCop::Config.new('Cop/Cop' => { 'AutoCorrect' => false })
end
it { is_expected.to be(false) }
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/corrector_spec.rb 0000664 0000000 0000000 00000003306 13070542236 0023664 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Corrector do
describe '#rewrite' do
it 'allows removal of a range' do
source = 'true and false'
processed_source = parse_source(source)
correction = lambda do |corrector|
node = processed_source.ast
corrector.remove(node.loc.operator)
end
corrector = described_class.new(processed_source.buffer, [correction])
expect(corrector.rewrite).to eq 'true false'
end
it 'allows insertion before a source range' do
source = 'true and false'
processed_source = parse_source(source)
correction = lambda do |corrector|
node = processed_source.ast
corrector.insert_before(node.loc.operator, ';nil ')
end
corrector = described_class.new(processed_source.buffer, [correction])
expect(corrector.rewrite).to eq 'true ;nil and false'
end
it 'allows insertion after a source range' do
source = 'true and false'
processed_source = parse_source(source)
correction = lambda do |corrector|
node = processed_source.ast
corrector.insert_after(node.loc.operator, ' nil;')
end
corrector = described_class.new(processed_source.buffer, [correction])
expect(corrector.rewrite).to eq 'true and nil; false'
end
it 'allows replacement of a range' do
source = 'true and false'
processed_source = parse_source(source)
correction = lambda do |corrector|
node = processed_source.ast
corrector.replace(node.loc.operator, 'or')
end
corrector = described_class.new(processed_source.buffer, [correction])
expect(corrector.rewrite).to eq 'true or false'
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/force_spec.rb 0000664 0000000 0000000 00000001357 13070542236 0022764 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Force do
subject(:force) { described_class.new(cops) }
let(:cops) { [double('cop1'), double('cop2')] }
describe '.force_name' do
it 'returns the class name without namespace' do
expect(RuboCop::Cop::VariableForce.force_name).to eq('VariableForce')
end
end
describe '#run_hook' do
it 'invokes a hook in all cops' do
cops.each do |cop|
expect(cop).to receive(:some_hook).with(:foo, :bar)
end
force.run_hook(:some_hook, :foo, :bar)
end
it 'does not invoke a hook if the cop does not respond to the hook' do
expect(cops.last).to receive(:some_hook).with(:foo, :bar)
force.run_hook(:some_hook, :foo, :bar)
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/ 0000775 0000000 0000000 00000000000 13070542236 0021267 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/ambiguous_block_association_spec.rb 0000664 0000000 0000000 00000006562 13070542236 0030400 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'spec_helper'
describe RuboCop::Cop::Lint::AmbiguousBlockAssociation do
subject(:cop) { described_class.new }
subject(:error_message) { described_class::MSG }
before { inspect_source(cop, source) }
shared_examples 'accepts' do |code|
let(:source) { code }
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
it_behaves_like 'accepts', 'foo == bar { baz a }'
it_behaves_like 'accepts', 'foo ->(a) { bar a }'
it_behaves_like 'accepts', 'some_method(a) { |el| puts el }'
it_behaves_like 'accepts', 'some_method(a) do;puts a;end'
it_behaves_like 'accepts', 'some_method a do;puts "dev";end'
it_behaves_like 'accepts', 'some_method a do |e|;puts e;end'
it_behaves_like 'accepts', 'Foo.bar(a) { |el| puts el }'
it_behaves_like 'accepts', 'env ENV.fetch("ENV") { "dev" }'
it_behaves_like 'accepts', 'env(ENV.fetch("ENV") { "dev" })'
it_behaves_like 'accepts', '{ f: "b"}.fetch(:a) do |e|;puts e;end'
it_behaves_like 'accepts', 'Hash[some_method(a) { |el| el }]'
it_behaves_like 'accepts', 'foo = lambda do |diagnostic|;end'
it_behaves_like 'accepts', 'Proc.new { puts "proc" }'
it_behaves_like('accepts', 'expect { order.save }.to(change { orders.size })')
it_behaves_like(
'accepts',
'assert_equal posts.find { |p| p.title == "Foo" }, results.first'
)
it_behaves_like(
'accepts',
'assert_equal(posts.find { |p| p.title == "Foo" }, results.first)'
)
it_behaves_like(
'accepts',
'assert_equal(results.first, posts.find { |p| p.title == "Foo" })'
)
it_behaves_like(
'accepts',
'allow(cop).to receive(:on_int) { raise RuntimeError }'
)
it_behaves_like(
'accepts',
'allow(cop).to(receive(:on_int) { raise RuntimeError })'
)
context 'without parentheses' do
context 'without receiver' do
let(:source) { 'some_method a { |el| puts el }' }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to(
eq(format(error_message, 'a { |el| puts el }', 'a'))
)
end
end
context 'with receiver' do
let(:source) { 'Foo.some_method a { |el| puts el }' }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to(
eq(format(error_message, 'a { |el| puts el }', 'a'))
)
end
end
context 'rspec expect {}.to change {}' do
let(:source) do
'expect { order.expire }.to change { order.events }'
end
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to(
eq(format(error_message, 'change { order.events }', 'change'))
)
end
end
context 'as a hash key' do
let(:source) { 'Hash[some_method a { |el| el }]' }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to(
eq(format(error_message, 'a { |el| el }', 'a'))
)
end
end
context 'with assignment' do
let(:source) { 'foo = some_method a { |el| puts el }' }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to(
eq(format(error_message, 'a { |el| puts el }', 'a'))
)
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/ambiguous_operator_spec.rb 0000664 0000000 0000000 00000005316 13070542236 0026541 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::AmbiguousOperator do
subject(:cop) { described_class.new }
before do
inspect_source(cop, source)
end
context 'with a splat operator in the first argument' do
context 'without parentheses' do
context 'without whitespaces on the right of the operator' do
let(:source) do
[
'array = [1, 2, 3]',
'puts *array'
]
end
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(
'Ambiguous splat operator. ' \
"Parenthesize the method arguments if it's surely a splat " \
'operator, ' \
'or add a whitespace to the right of the `*` if it should be a ' \
'multiplication.'
)
expect(cop.highlights).to eq(['*'])
end
end
context 'with a whitespace on the right of the operator' do
let(:source) do
[
'array = [1, 2, 3]',
'puts * array'
]
end
it 'accepts' do
expect(cop.offenses).to be_empty
end
end
end
context 'with parentheses' do
let(:source) do
[
'array = [1, 2, 3]',
'puts(*array)'
]
end
it 'accepts' do
expect(cop.offenses).to be_empty
end
end
end
context 'with a block ampersand in the first argument' do
context 'without parentheses' do
context 'without whitespaces on the right of the operator' do
let(:source) do
[
'process = proc { do_something }',
'2.times &process'
]
end
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(
'Ambiguous block operator. ' \
"Parenthesize the method arguments if it's surely a block " \
'operator, ' \
'or add a whitespace to the right of the `&` if it should be a ' \
'binary AND.'
)
expect(cop.highlights).to eq(['&'])
end
end
context 'with a whitespace on the right of the operator' do
let(:source) do
[
'process = proc { do_something }',
'2.times & process'
]
end
it 'accepts' do
expect(cop.offenses).to be_empty
end
end
end
context 'with parentheses' do
let(:source) do
[
'process = proc { do_something }',
'2.times(&process)'
]
end
it 'accepts' do
expect(cop.offenses).to be_empty
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/ambiguous_regexp_literal_spec.rb 0000664 0000000 0000000 00000001564 13070542236 0027715 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::AmbiguousRegexpLiteral do
subject(:cop) { described_class.new }
before do
inspect_source(cop, source)
end
context 'with a regexp literal in the first argument' do
context 'without parentheses' do
let(:source) { 'p /pattern/' }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(
'Ambiguous regexp literal. Parenthesize the method arguments ' \
"if it's surely a regexp literal, or add a whitespace to the " \
'right of the `/` if it should be a division.'
)
expect(cop.highlights).to eq(['/'])
end
end
context 'with parentheses' do
let(:source) { 'p(/pattern/)' }
it 'accepts' do
expect(cop.offenses).to be_empty
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/assignment_in_condition_spec.rb 0000664 0000000 0000000 00000010657 13070542236 0027543 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::AssignmentInCondition, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'AllowSafeAssignment' => true } }
it 'registers an offense for lvar assignment in condition' do
inspect_source(cop,
['if test = 10',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for lvar assignment in while condition' do
inspect_source(cop,
['while test = 10',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for lvar assignment in until condition' do
inspect_source(cop,
['until test = 10',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for ivar assignment in condition' do
inspect_source(cop,
['if @test = 10',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for clvar assignment in condition' do
inspect_source(cop,
['if @@test = 10',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for gvar assignment in condition' do
inspect_source(cop,
['if $test = 10',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for constant assignment in condition' do
inspect_source(cop,
['if TEST = 10',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for collection element assignment in condition' do
inspect_source(cop,
['if a[3] = 10',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'accepts == in condition' do
inspect_source(cop,
['if test == 10',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for assignment after == in condition' do
inspect_source(cop,
['if test == 10 || foobar = 1',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'accepts = in a block that is called in a condition' do
inspect_source(cop,
'return 1 if any_errors? { o = inspect(file) }')
expect(cop.offenses).to be_empty
end
it 'accepts = in a block followed by method call' do
inspect_source(cop,
'return 1 if any_errors? { o = file }.present?')
expect(cop.offenses).to be_empty
end
it 'accepts ||= in condition' do
inspect_source(cop,
'raise StandardError unless foo ||= bar')
expect(cop.offenses).to be_empty
end
it 'registers an offense for assignment after ||= in condition' do
inspect_source(cop,
'raise StandardError unless (foo ||= bar) || a = b')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for assignment methods' do
inspect_source(cop,
['if test.method = 10',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'does not blow up for empty if condition' do
inspect_source(cop,
['if ()',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not blow up for empty unless condition' do
inspect_source(cop,
['unless ()',
'end'])
expect(cop.offenses).to be_empty
end
context 'safe assignment is allowed' do
it 'accepts = in condition surrounded with braces' do
inspect_source(cop,
['if (test = 10)',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts []= in condition surrounded with braces' do
inspect_source(cop,
['if (test[0] = 10)',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'safe assignment is not allowed' do
let(:cop_config) { { 'AllowSafeAssignment' => false } }
it 'does not accept = in condition surrounded with braces' do
inspect_source(cop,
['if (test = 10)',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'does not accept []= in condition surrounded with braces' do
inspect_source(cop,
['if (test[0] = 10)',
'end'])
expect(cop.offenses.size).to eq(1)
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/block_alignment_spec.rb 0000664 0000000 0000000 00000055421 13070542236 0025765 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::BlockAlignment, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) do
{ 'EnforcedStyleAlignWith' => 'either' }
end
context 'when the block has no arguments' do
it 'registers an offense for mismatched block end' do
inspect_source(cop,
['test do',
' end'])
expect(cop.messages)
.to eq(['`end` at 2, 2 is not aligned with `test do` at 1, 0.'])
end
it 'auto-corrects alignment' do
new_source = autocorrect_source(cop, ['test do',
' end'])
expect(new_source).to eq(['test do',
'end'].join("\n"))
end
end
context 'when the block has arguments' do
it 'registers an offense for mismatched block end' do
inspect_source(cop,
['test do |ala|',
' end'])
expect(cop.messages)
.to eq(['`end` at 2, 2 is not aligned with `test do |ala|` at 1, 0.'])
end
it 'auto-corrects alignment' do
new_source = autocorrect_source(cop, ['test do |ala|',
' end'])
expect(new_source).to eq(['test do |ala|',
'end'].join("\n"))
end
end
it 'accepts a block end that does not begin its line' do
inspect_source(cop,
[' scope :bar, lambda { joins(:baz)',
' .distinct }'])
expect(cop.offenses).to be_empty
end
context 'when the block is a logical operand' do
it 'accepts a correctly aligned block end' do
inspect_source(cop,
['(value.is_a? Array) && value.all? do |subvalue|',
' type_check_value(subvalue, array_type)',
'end',
'a || b do',
'end'])
expect(cop.offenses).to be_empty
end
end
it 'accepts end aligned with a variable' do
inspect_source(cop,
['variable = test do |ala|',
'end'])
expect(cop.offenses).to be_empty
end
context 'when there is an assignment chain' do
it 'registers an offense for an end aligned with the 2nd variable' do
inspect_source(cop,
['a = b = c = test do |ala|',
' end'])
expect(cop.messages)
.to eq(['`end` at 2, 4 is not aligned with' \
' `a = b = c = test do |ala|` at 1, 0.'])
end
it 'accepts end aligned with the first variable' do
inspect_source(cop,
['a = b = c = test do |ala|',
'end'])
expect(cop.offenses).to be_empty
end
it 'auto-corrects alignment to the first variable' do
new_source = autocorrect_source(cop,
['a = b = c = test do |ala|',
' end'])
expect(new_source).to eq(['a = b = c = test do |ala|',
'end'].join("\n"))
end
end
context 'and the block is an operand' do
it 'accepts end aligned with a variable' do
inspect_source(cop,
['b = 1 + preceding_line.reduce(0) do |a, e|',
' a + e.length + newline_length',
'end + 1'])
expect(cop.offenses).to be_empty
end
end
it 'registers an offense for mismatched block end with a variable' do
inspect_source(cop,
['variable = test do |ala|',
' end'])
expect(cop.messages)
.to eq(['`end` at 2, 2 is not aligned with `variable = test do |ala|`' \
' at 1, 0.'])
end
context 'when the block is defined on the next line' do
it 'accepts end aligned with the block expression' do
inspect_source(cop,
['variable =',
' a_long_method_that_dont_fit_on_the_line do |v|',
' v.foo',
' end'])
expect(cop.offenses).to be_empty
end
it 'registers an offenses for mismatched end alignment' do
inspect_source(cop,
['variable =',
' a_long_method_that_dont_fit_on_the_line do |v|',
' v.foo',
'end'])
expect(cop.messages)
.to eq(['`end` at 4, 0 is not aligned with' \
' `a_long_method_that_dont_fit_on_the_line do |v|` at 2, 2.'])
end
it 'auto-corrects alignment' do
new_source = autocorrect_source(
cop,
['variable =',
' a_long_method_that_dont_fit_on_the_line do |v|',
' v.foo',
'end']
)
expect(new_source)
.to eq(['variable =',
' a_long_method_that_dont_fit_on_the_line do |v|',
' v.foo',
' end'].join("\n"))
end
end
context 'when the method part is a call chain that spans several lines' do
# Example from issue 346 of bbatsov/rubocop on github:
it 'accepts pretty alignment style' do
src = [
'def foo(bar)',
' bar.get_stuffs',
' .reject do |stuff| ',
' stuff.with_a_very_long_expression_that_doesnt_fit_the_line',
' end.select do |stuff|',
' stuff.another_very_long_expression_that_doesnt_fit_the_line',
' end',
' .select do |stuff|',
' stuff.another_very_long_expression_that_doesnt_fit_the_line',
' end',
'end'
]
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'registers offenses for misaligned ends' do
src = [
'def foo(bar)',
' bar.get_stuffs',
' .reject do |stuff|',
' stuff.with_a_very_long_expression_that_doesnt_fit_the_line',
' end.select do |stuff|',
' stuff.another_very_long_expression_that_doesnt_fit_the_line',
' end',
' .select do |stuff|',
' stuff.another_very_long_expression_that_doesnt_fit_the_line',
' end',
'end'
]
inspect_source(cop, src)
expect(cop.messages)
.to eq(['`end` at 5, 8 is not aligned with `bar.get_stuffs` at 2, 2' \
' or `.reject do |stuff|` at 3, 6.',
'`end` at 7, 4 is not aligned with `bar.get_stuffs` at 2, 2' \
' or `end.select do |stuff|` at 5, 8.',
'`end` at 10, 8 is not aligned with `bar.get_stuffs` at 2, 2' \
' or `.select do |stuff|` at 8, 6.'])
end
# Example from issue 393 of bbatsov/rubocop on github:
it 'accepts end indented as the start of the block' do
src = ['my_object.chaining_this_very_long_method(with_a_parameter)',
' .and_one_with_a_block do',
' do_something',
'end',
'', # Other variant:
'my_object.chaining_this_very_long_method(',
' with_a_parameter).and_one_with_a_block do',
' do_something',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
# Example from issue 447 of bbatsov/rubocop on github:
it 'accepts two kinds of end alignment' do
src = [
# Aligned with start of line where do is:
'params = default_options.merge(options)',
' .delete_if { |k, v| v.nil? }',
' .each_with_object({}) do |(k, v), new_hash|',
' new_hash[k.to_s] = v.to_s',
' end',
# Aligned with start of the whole expression:
'params = default_options.merge(options)',
' .delete_if { |k, v| v.nil? }',
' .each_with_object({}) do |(k, v), new_hash|',
' new_hash[k.to_s] = v.to_s',
'end'
]
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'auto-corrects misaligned ends with the start of the expression' do
src = [
'def foo(bar)',
' bar.get_stuffs',
' .reject do |stuff|',
' stuff.with_a_very_long_expression_that_doesnt_fit_the_line',
' end.select do |stuff|',
' stuff.another_very_long_expression_that_doesnt_fit_the_line',
' end',
' .select do |stuff|',
' stuff.another_very_long_expression_that_doesnt_fit_the_line',
' end',
'end'
]
aligned_src = [
'def foo(bar)',
' bar.get_stuffs',
' .reject do |stuff|',
' stuff.with_a_very_long_expression_that_doesnt_fit_the_line',
' end.select do |stuff|',
' stuff.another_very_long_expression_that_doesnt_fit_the_line',
' end',
' .select do |stuff|',
' stuff.another_very_long_expression_that_doesnt_fit_the_line',
' end',
'end'
].join("\n")
new_source = autocorrect_source(cop, src)
expect(new_source).to eq(aligned_src)
end
end
context 'when variables of a mass assignment spans several lines' do
it 'accepts end aligned with the variables' do
src = ['e,',
'f = [5, 6].map do |i|',
' i - 5',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'registers an offense for end aligned with the block' do
src = ['e,',
'f = [5, 6].map do |i|',
' i - 5',
' end']
inspect_source(cop, src)
expect(cop.messages)
.to eq(['`end` at 4, 4 is not aligned with `e,` at 1, 0 or' \
' `f = [5, 6].map do |i|` at 2, 0.'])
end
it 'auto-corrects' do
src = ['e,',
'f = [5, 6].map do |i|',
' i - 5',
' end']
corrected = ['e,',
'f = [5, 6].map do |i|',
' i - 5',
'end']
new_source = autocorrect_source(cop, src)
expect(new_source).to eq(corrected.join("\n"))
end
end
it 'accepts end aligned with an instance variable' do
inspect_source(cop,
['@variable = test do |ala|',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for mismatched block end with' \
' an instance variable' do
inspect_source(cop,
['@variable = test do |ala|',
' end'])
expect(cop.messages)
.to eq(['`end` at 2, 2 is not aligned with `@variable = test do |ala|`' \
' at 1, 0.'])
end
it 'accepts end aligned with a class variable' do
inspect_source(cop,
['@@variable = test do |ala|',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for mismatched block end with a class variable' do
inspect_source(cop,
['@@variable = test do |ala|',
' end'])
expect(cop.messages)
.to eq(['`end` at 2, 2 is not aligned with `@@variable = test do |ala|`' \
' at 1, 0.'])
end
it 'accepts end aligned with a global variable' do
inspect_source(cop,
['$variable = test do |ala|',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for mismatched block end with a global variable' do
inspect_source(cop,
['$variable = test do |ala|',
' end'])
expect(cop.messages)
.to eq(['`end` at 2, 2 is not aligned with `$variable = test do |ala|`' \
' at 1, 0.'])
end
it 'accepts end aligned with a constant' do
inspect_source(cop,
['CONSTANT = test do |ala|',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for mismatched block end with a constant' do
inspect_source(cop,
['Module::CONSTANT = test do |ala|',
' end'])
expect(cop.messages)
.to eq(['`end` at 2, 2 is not aligned with' \
' `Module::CONSTANT = test do |ala|` at 1, 0.'])
end
it 'accepts end aligned with a method call' do
inspect_source(cop,
['parser.children << lambda do |token|',
' token << 1',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for mismatched block end with a method call' do
inspect_source(cop,
['parser.children << lambda do |token|',
' token << 1',
' end'])
expect(cop.messages)
.to eq(['`end` at 3, 2 is not aligned with' \
' `parser.children << lambda do |token|` at 1, 0.'])
end
it 'accepts end aligned with a method call with arguments' do
inspect_source(cop,
['@h[:f] = f.each_pair.map do |f, v|',
' v = 1',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for mismatched end with a method call' \
' with arguments' do
inspect_source(cop,
['@h[:f] = f.each_pair.map do |f, v|',
' v = 1',
' end'])
expect(cop.messages)
.to eq(['`end` at 3, 2 is not aligned with' \
' `@h[:f] = f.each_pair.map do |f, v|` at 1, 0.'])
end
it 'does not raise an error for nested block in a method call' do
inspect_source(cop,
'expect(arr.all? { |o| o.valid? })')
expect(cop.offenses).to be_empty
end
it 'accepts end aligned with the block when the block is a method argument' do
inspect_source(cop,
['expect(arr.all? do |o|',
' o.valid?',
' end)'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for mismatched end not aligned with the block' \
' that is an argument' do
inspect_source(cop,
['expect(arr.all? do |o|',
' o.valid?',
' end)'])
expect(cop.messages)
.to eq(['`end` at 3, 2 is not aligned with `arr.all? do |o|` at 1, 7 or' \
' `expect(arr.all? do |o|` at 1, 0.'])
end
it 'accepts end aligned with an op-asgn (+=, -=)' do
inspect_source(cop,
['rb += files.select do |file|',
' file << something',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for mismatched block end with an op-asgn (+=, -=)' do
inspect_source(cop,
['rb += files.select do |file|',
' file << something',
' end'])
expect(cop.messages)
.to eq(['`end` at 3, 2 is not aligned with `rb` at 1, 0.'])
end
it 'accepts end aligned with an and-asgn (&&=)' do
inspect_source(cop,
['variable &&= test do |ala|',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for mismatched block end with an and-asgn (&&=)' do
inspect_source(cop,
['variable &&= test do |ala|',
' end'])
expect(cop.messages)
.to eq(['`end` at 2, 2 is not aligned with `variable &&= test do |ala|`' \
' at 1, 0.'])
end
it 'accepts end aligned with an or-asgn (||=)' do
inspect_source(cop,
['variable ||= test do |ala|',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for mismatched block end with an or-asgn (||=)' do
inspect_source(cop,
['variable ||= test do |ala|',
' end'])
expect(cop.messages)
.to eq(['`end` at 2, 2 is not aligned with `variable ||= test do |ala|`' \
' at 1, 0.'])
end
it 'accepts end aligned with a mass assignment' do
inspect_source(cop,
['var1, var2 = lambda do |test|',
' [1, 2]',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts end aligned with a call chain left hand side' do
inspect_source(cop,
['parser.diagnostics.consumer = lambda do |diagnostic|',
' diagnostics << diagnostic',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for mismatched block end with a mass assignment' do
inspect_source(cop,
['var1, var2 = lambda do |test|',
' [1, 2]',
' end'])
expect(cop.messages)
.to eq(['`end` at 3, 2 is not aligned with `var1, var2` at 1, 0.'])
end
context 'when multiple similar-looking blocks have misaligned ends' do
it 'registers an offense for each of them' do
inspect_source(cop,
['a = test do',
' end',
'b = test do',
' end'])
expect(cop.offenses.size).to eq 2
end
end
context 'on a splatted method call' do
it 'aligns end with the splat operator' do
inspect_source(cop,
['def get_gems_by_name',
' @gems ||= Hash[*get_latest_gems.map { |gem|',
' [gem.name, gem, gem.full_name, gem]',
' }.flatten]',
'end'])
expect(cop.offenses).to be_empty
end
it 'autocorrects' do
source = ['def get_gems_by_name',
' @gems ||= Hash[*get_latest_gems.map { |gem|',
' [gem.name, gem, gem.full_name, gem]',
' }.flatten]',
'end']
corrected = ['def get_gems_by_name',
' @gems ||= Hash[*get_latest_gems.map { |gem|',
' [gem.name, gem, gem.full_name, gem]',
' }.flatten]',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(corrected.join("\n"))
end
end
context 'on a bit-flipped method call' do
it 'aligns end with the ~ operator' do
inspect_source(cop,
['def abc',
' @abc ||= A[~xyz { |x|',
' x',
' }.flatten]',
'end'])
expect(cop.offenses).to be_empty
end
it 'autocorrects' do
source = ['def abc',
' @abc ||= A[~xyz { |x|',
' x',
' }.flatten]',
'end']
corrected = ['def abc',
' @abc ||= A[~xyz { |x|',
' x',
' }.flatten]',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(corrected.join("\n"))
end
end
context 'on a logically negated method call' do
it 'aligns end with the ! operator' do
inspect_source(cop,
['def abc',
' @abc ||= A[!xyz { |x|',
' x',
' }.flatten]',
'end'])
expect(cop.offenses).to be_empty
end
it 'autocorrects' do
source = ['def abc',
' @abc ||= A[!xyz { |x|',
' x',
'}.flatten]',
'end']
corrected = ['def abc',
' @abc ||= A[!xyz { |x|',
' x',
' }.flatten]',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(corrected.join("\n"))
end
end
context 'on an arithmetically negated method call' do
it 'aligns end with the - operator' do
inspect_source(cop,
['def abc',
' @abc ||= A[-xyz { |x|',
' x',
' }.flatten]',
'end'])
expect(cop.offenses).to be_empty
end
it 'autocorrects' do
source = ['def abc',
' @abc ||= A[-xyz { |x|',
' x',
' }.flatten]',
'end']
corrected = ['def abc',
' @abc ||= A[-xyz { |x|',
' x',
' }.flatten]',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(corrected.join("\n"))
end
end
context 'when the block is terminated by }' do
it 'mentions } (not end) in the message' do
inspect_source(cop,
['test {',
' }'])
expect(cop.messages)
.to eq(['`}` at 2, 2 is not aligned with `test {` at 1, 0.'])
end
end
context 'when configured to align with start_of_line' do
let(:cop_config) do
{ 'EnforcedStyleAlignWith' => 'start_of_line' }
end
it 'allows when start_of_line aligned' do
src = [
'foo.bar',
' .each do',
' baz',
'end'
]
inspect_source(cop, src)
expect(cop.messages).to be_empty
end
it 'errors when do aligned' do
src = [
'foo.bar',
' .each do',
' baz',
' end'
]
inspect_source(cop, src)
expect(cop.messages)
.to eq(['`end` at 4, 2 is not aligned with ' \
'`foo.bar` at 1, 0.'])
end
it 'autocorrects' do
src = [
'foo.bar',
' .each do',
' baz',
' end'
]
corrected = [
'foo.bar',
' .each do',
' baz',
'end'
]
new_source = autocorrect_source(cop, src)
expect(new_source).to eq(corrected.join("\n"))
end
end
context 'when configured to align with do' do
let(:cop_config) do
{ 'EnforcedStyleAlignWith' => 'start_of_block' }
end
it 'allows when do aligned' do
src = [
'foo.bar',
' .each do',
' baz',
' end'
]
inspect_source(cop, src)
expect(cop.messages).to be_empty
end
it 'errors when start_of_line aligned' do
src = [
'foo.bar',
' .each do',
' baz',
'end'
]
inspect_source(cop, src)
expect(cop.messages)
.to eq(['`end` at 4, 0 is not aligned with ' \
'`.each do` at 2, 2.'])
end
it 'autocorrects' do
src = [
'foo.bar',
' .each do',
' baz',
'end'
]
corrected = [
'foo.bar',
' .each do',
' baz',
' end'
]
new_source = autocorrect_source(cop, src)
expect(new_source).to eq(corrected.join("\n"))
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/circular_argument_reference_spec.rb 0000664 0000000 0000000 00000011053 13070542236 0030352 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::CircularArgumentReference do
subject(:cop) { described_class.new }
describe 'circular argument references in ordinal arguments' do
before do
inspect_source(cop, source)
end
context 'when the method contains a circular argument reference' do
let(:source) do
[
'def omg_wow(msg = msg)',
' puts msg',
'end'
]
end
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Circular argument reference - `msg`.')
expect(cop.highlights).to eq ['msg']
end
end
context 'when the method does not contain a circular argument reference' do
let(:source) do
[
'def omg_wow(msg)',
' puts msg',
'end'
]
end
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
context 'when the seemingly-circular default value is a method call' do
let(:source) do
[
'def omg_wow(msg = self.msg)',
' puts msg',
'end'
]
end
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
end
describe 'circular argument references in keyword arguments' do
context 'ruby < 2.0, which has no keyword arguments', :ruby19 do
let(:source) do
[
'def some_method(some_arg: some_method)',
' puts some_arg',
'end'
]
end
it 'fails with a syntax error before the cop even comes into play' do
expect { inspect_source(cop, source) }.to raise_error(
RuntimeError, /Error parsing/
)
expect(cop.offenses).to be_empty
end
end
context 'ruby >= 2.0', :ruby20 do
before do
inspect_source(cop, source)
end
context 'when the keyword argument is not circular' do
let(:source) do
[
'def some_method(some_arg: nil)',
' puts some_arg',
'end'
]
end
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
context 'when the keyword argument is not circular, and calls a method' do
let(:source) do
[
'def some_method(some_arg: some_method)',
' puts some_arg',
'end'
]
end
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
context 'when there is one circular argument reference' do
let(:source) do
[
'def some_method(some_arg: some_arg)',
' puts some_arg',
'end'
]
end
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Circular argument reference - `some_arg`.')
expect(cop.highlights).to eq ['some_arg']
end
end
context 'when the keyword argument is not circular, but calls a method ' \
'of its own class with a self specification' do
let(:source) do
[
'def puts_value(value: self.class.value, smile: self.smile)',
' puts value',
'end'
]
end
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
context 'when the keyword argument is not circular, but calls a method ' \
'of some other object with the same name' do
let(:source) do
[
'def puts_length(length: mystring.length)',
' puts length',
'end'
]
end
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
context 'when there are multiple offensive keyword arguments' do
let(:source) do
[
'def some_method(some_arg: some_arg, other_arg: other_arg)',
' puts [some_arg, other_arg]',
'end'
]
end
it 'registers two offenses' do
expect(cop.offenses.size).to eq(2)
expect(cop.offenses.first.message)
.to eq('Circular argument reference - `some_arg`.')
expect(cop.offenses.last.message)
.to eq('Circular argument reference - `other_arg`.')
expect(cop.highlights).to eq %w[some_arg other_arg]
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/condition_position_spec.rb 0000664 0000000 0000000 00000002445 13070542236 0026545 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::ConditionPosition do
subject(:cop) { described_class.new }
%w[if unless while until].each do |keyword|
it 'registers an offense for condition on the next line' do
inspect_source(cop,
[keyword,
'x == 10',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'accepts condition on the same line' do
inspect_source(cop,
["#{keyword} x == 10",
' bala',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts condition on a different line for modifiers' do
inspect_source(cop,
["do_something #{keyword}",
' something && something_else'])
expect(cop.offenses).to be_empty
end
end
it 'registers an offense for elsif condition on the next line' do
inspect_source(cop,
['if something',
' test',
'elsif',
' something',
' test',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'handles ternary ops' do
inspect_source(cop, 'x ? a : b')
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/debugger_spec.rb 0000664 0000000 0000000 00000005122 13070542236 0024412 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::Debugger, :config do
subject(:cop) { described_class.new(config) }
include_examples 'debugger', 'debugger', 'debugger'
include_examples 'debugger', 'byebug', 'byebug'
include_examples 'debugger', 'pry binding', %w[binding.pry binding.remote_pry
binding.pry_remote]
include_examples 'debugger',
'capybara debug method', %w[save_and_open_page
save_and_open_screenshot
save_screenshot]
include_examples 'debugger', 'debugger with an argument', 'debugger foo'
include_examples 'debugger', 'byebug with an argument', 'byebug foo'
include_examples 'debugger',
'pry binding with an argument', ['binding.pry foo',
'binding.remote_pry foo',
'binding.pry_remote foo']
include_examples 'debugger',
'capybara debug method with an argument',
['save_and_open_page foo',
'save_and_open_screenshot foo',
'save_screenshot foo']
include_examples 'non-debugger', 'a non-pry binding', 'binding.pirate'
ALL_COMMANDS = %w[debugger byebug pry remote_pry pry_remote irb
save_and_open_page save_and_open_screenshot
save_screenshot].freeze
ALL_COMMANDS.each do |src|
include_examples 'non-debugger', "a #{src} in comments", "# #{src}"
include_examples 'non-debugger', "a #{src} method", "code.#{src}"
end
it 'reports an offense for a Pry.rescue call' do
inspect_source(cop, ['def method',
' Pry.rescue { puts 1 }',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Remove debugger entry point `Pry.rescue`.'])
end
it 'can autocorrect Pry.rescue' do
new_source = autocorrect_source(cop, ['def method',
' Pry.rescue { puts 1 }',
'end'])
expect(new_source).to eq(['def method',
' puts 1',
'end'].join("\n"))
end
context 'target_ruby_version >= 2.4', :ruby24 do
include_examples 'debugger', 'irb binding', 'binding.irb'
ALL_COMMANDS.each do |src|
include_examples 'non-debugger', "a #{src} in comments", "# #{src}"
include_examples 'non-debugger', "a #{src} method", "code.#{src}"
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/def_end_alignment_spec.rb 0000664 0000000 0000000 00000006440 13070542236 0026254 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::DefEndAlignment, :config do
subject(:cop) { described_class.new(config) }
let(:source) do
['foo def a',
' a1',
'end',
'',
'foo def b',
' b1',
' end']
end
context 'when EnforcedStyleAlignWith is start_of_line' do
let(:cop_config) do
{ 'EnforcedStyleAlignWith' => 'start_of_line', 'AutoCorrect' => true }
end
include_examples 'misaligned', '', 'def', 'test', ' end'
include_examples 'misaligned', '', 'def', 'Test.test', ' end', 'defs'
include_examples 'aligned', "\xef\xbb\xbfdef", 'test', 'end'
include_examples 'aligned', 'def', 'test', 'end'
include_examples 'aligned', 'def', 'Test.test', 'end', 'defs'
context 'in ruby 2.1 or later' do
include_examples 'aligned', 'foo def', 'test', 'end'
include_examples('misaligned', '',
'foo def', 'test',
' end')
end
context 'correct + opposite' do
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.messages.first)
.to eq('`end` at 7, 4 is not aligned with `foo def` at 5, 0.')
expect(cop.highlights.first).to eq('end')
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'does auto-correction' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq(['foo def a',
' a1',
'end',
'',
'foo def b',
' b1',
'end'].join("\n"))
end
end
end
context 'when EnforcedStyleAlignWith is def' do
let(:cop_config) do
{ 'EnforcedStyleAlignWith' => 'def', 'AutoCorrect' => true }
end
include_examples 'misaligned', '', 'def', 'test', ' end'
include_examples 'misaligned', '', 'def', 'Test.test', ' end', 'defs'
include_examples 'aligned', 'def', 'test', 'end'
include_examples 'aligned', 'def', 'Test.test', 'end', 'defs'
context 'in ruby 2.1 or later' do
include_examples('aligned',
'foo def', 'test',
' end')
include_examples('misaligned',
'foo ', 'def', 'test',
'end')
context 'correct + opposite' do
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.messages.first)
.to eq('`end` at 3, 0 is not aligned with `def` at 1, 4.')
expect(cop.highlights.first).to eq('end')
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'does auto-correction' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq(['foo def a',
' a1',
' end',
'',
'foo def b',
' b1',
' end'].join("\n"))
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/deprecated_class_methods_spec.rb 0000664 0000000 0000000 00000002477 13070542236 0027650 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::DeprecatedClassMethods do
subject(:cop) { described_class.new }
it 'registers an offense for File.exists?' do
inspect_source(cop, 'File.exists?(o)')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['`File.exists?` is deprecated in favor of `File.exist?`.'])
end
it 'registers an offense for ::File.exists?' do
inspect_source(cop, '::File.exists?(o)')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['`File.exists?` is deprecated in favor of `File.exist?`.'])
end
it 'does not register an offense for File.exist?' do
inspect_source(cop, 'File.exist?(o)')
expect(cop.messages).to be_empty
end
it 'registers an offense for Dir.exists?' do
inspect_source(cop, 'Dir.exists?(o)')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['`Dir.exists?` is deprecated in favor of `Dir.exist?`.'])
end
it 'auto-corrects File.exists? with File.exist?' do
new_source = autocorrect_source(cop, 'File.exists?(something)')
expect(new_source).to eq('File.exist?(something)')
end
it 'auto-corrects Dir.exists? with Dir.exist?' do
new_source = autocorrect_source(cop, 'Dir.exists?(something)')
expect(new_source).to eq('Dir.exist?(something)')
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/duplicate_case_condition_spec.rb 0000664 0000000 0000000 00000006651 13070542236 0027651 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::DuplicateCaseCondition do
subject(:cop) { described_class.new }
it 'registers an offense for repeated case conditionals' do
inspect_source(cop, ['case x',
'when false',
' first_method',
'when true',
' second_method',
'when false',
' third_method',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for subsequent repeated case conditionals' do
inspect_source(cop, ['case x',
'when false',
' first_method',
'when false',
' second_method',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers multiple offenses for multiple repeated case conditionals' do
inspect_source(cop, ['case x',
'when false',
' first_method',
'when true',
' second_method',
'when false',
' third_method',
'when true',
' fourth_method',
'end'])
expect(cop.offenses.size).to eq(2)
end
it 'registers multiple offenses for repeated multi-value condtionals' do
inspect_source(cop, ['case x',
'when a, b',
' first_method',
'when b, a',
' second_method',
'end'])
expect(cop.offenses.size).to eq(2)
end
it 'registers an offense for repeated logical operator when expressions' do
inspect_source(cop, ['case x',
'when a && b',
' first_method',
'when a && b',
' second_method',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'accepts trivial case expressions' do
inspect_source(cop, ['case x',
'when false',
' first_method',
'end'])
expect(cop.messages).to be_empty
end
it 'accepts non-redundant case expressions' do
inspect_source(cop, ['case x',
'when false',
' first_method',
'when true',
' second_method',
'end'])
expect(cop.messages).to be_empty
end
it 'accepts non-redundant case expressions with an else expression' do
inspect_source(cop, ['case x',
'when false',
' method_name',
'when true',
' second_method',
'else',
' third_method',
'end'])
expect(cop.messages).to be_empty
end
it 'accepts similar but not equivalent && expressions' do
inspect_source(cop, ['case x',
'when something && another && other',
' first_method',
'when something && another',
' second_method',
'end'])
expect(cop.messages).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/duplicate_methods_spec.rb 0000664 0000000 0000000 00000027325 13070542236 0026334 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::DuplicateMethods do
subject(:cop) { described_class.new }
shared_examples 'in scope' do |type, opening_line|
it "registers an offense for duplicate method in #{type}" do
inspect_source(cop,
[opening_line,
' def some_method',
' implement 1',
' end',
' def some_method',
' implement 2',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
end
it "doesn't register an offense for non-duplicate method in #{type}" do
inspect_source(cop,
[opening_line,
' def some_method',
' implement 1',
' end',
' def any_method',
' implement 2',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it "registers an offense for duplicate class methods in #{type}" do
inspect_source(cop,
[opening_line,
' def self.some_method',
' implement 1',
' end',
' def self.some_method',
' implement 2',
' end',
'end'], 'src.rb')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['Method `A.some_method` is defined at both src.rb:2 and src.rb:5.']
)
end
it "doesn't register offense for non-duplicate class methods in #{type}" do
inspect_source(cop,
[opening_line,
' def self.some_method',
' implement 1',
' end',
' def self.any_method',
' implement 2',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it "recognizes difference between instance and class methods in #{type}" do
inspect_source(cop,
[opening_line,
' def some_method',
' implement 1',
' end',
' def self.some_method',
' implement 2',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it "registers an offense for duplicate private methods in #{type}" do
inspect_source(cop,
[opening_line,
' private def some_method',
' implement 1',
' end',
' private def some_method',
' implement 2',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
end
it "registers an offense for duplicate private self methods in #{type}" do
inspect_source(cop,
[opening_line,
' private def self.some_method',
' implement 1',
' end',
' private def self.some_method',
' implement 2',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
end
it "doesn't register an offense for different private methods in #{type}" do
inspect_source(cop,
[opening_line,
' private def some_method',
' implement 1',
' end',
' private def any_method',
' implement 2',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it "registers an offense for duplicate protected methods in #{type}" do
inspect_source(cop,
[opening_line,
' protected def some_method',
' implement 1',
' end',
' protected def some_method',
' implement 2',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
end
it "registers 2 offenses for pair of duplicate methods in #{type}" do
inspect_source(cop,
[opening_line,
' def some_method',
' implement 1',
' end',
' def some_method',
' implement 2',
' end',
' def any_method',
' implement 1',
' end',
' def any_method',
' implement 2',
' end',
'end'], 'dups.rb')
expect(cop.offenses.size).to eq(2)
expect(cop.messages).to contain_exactly(
'Method `A#any_method` is defined at both dups.rb:8 and dups.rb:11.',
'Method `A#some_method` is defined at both dups.rb:2 and dups.rb:5.'
)
end
it 'registers an offense for a duplicate instance method in separate ' \
"#{type} blocks" do
inspect_source(cop,
[opening_line,
' def some_method',
' implement 1',
' end',
'end',
opening_line,
' def some_method',
' implement 2',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for a duplicate class method in separate ' \
"#{type} blocks" do
inspect_source(cop,
[opening_line,
' def self.some_method',
' implement 1',
' end',
'end',
opening_line,
' def self.some_method',
' implement 2',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers offense for a duplicate instance method in separate files' do
inspect_source(cop,
[opening_line,
' def some_method',
' implement 1',
' end',
'end'], 'first.rb')
inspect_source(cop,
[opening_line,
' def some_method',
' implement 2',
' end',
'end'], 'second.rb')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Method `A#some_method` is defined at both ' \
'first.rb:2 and second.rb:2.'])
end
it 'understands class << self' do
inspect_source(cop,
[opening_line,
' class << self',
' def some_method',
' implement 1',
' end',
' def some_method',
' implement 2',
' end',
' end',
'end'], 'test.rb')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['Method `A.some_method` is defined at both test.rb:3 and test.rb:6.']
)
end
it 'understands nested modules' do
inspect_source(cop,
['module B',
" #{opening_line}",
' def some_method',
' implement 1',
' end',
' def some_method',
' implement 2',
' end',
' def self.another',
' end',
' def self.another',
' end',
' end',
'end'], 'test.rb')
expect(cop.offenses.size).to eq(2)
expect(cop.messages).to eq(
['Method `B::A#some_method` is defined at both test.rb:3 and ' \
'test.rb:6.',
'Method `B::A.another` is defined at both test.rb:9 and test.rb:11.']
)
end
it "doesn't register an offense when class << exp is used" do
inspect_source(cop,
[opening_line,
' class << blah',
' def some_method',
' implement 1',
' end',
' def some_method',
' implement 2',
' end',
' end',
'end'], 'test.rb')
expect(cop.offenses).to be_empty
end
end
include_examples('in scope', 'class', 'class A')
include_examples('in scope', 'module', 'module A')
include_examples('in scope', 'dynamic class', 'A = Class.new do')
include_examples('in scope', 'dynamic module', 'A = Module.new do')
include_examples('in scope', 'class_eval block', 'A.class_eval do')
it 'registers an offense for duplicate methods at top level' do
inspect_source(cop,
[' def some_method',
' implement 1',
' end',
' def some_method',
' implement 2',
' end'], 'toplevel.rb')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['Method `Object#some_method` is defined at both toplevel.rb:1 and ' \
'toplevel.rb:4.']
)
end
it 'understands class << A' do
inspect_source(cop,
['class << A',
' def some_method',
' implement 1',
' end',
' def some_method',
' implement 2',
' end',
'end'], 'test.rb')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['Method `A.some_method` is defined at both test.rb:2 and test.rb:5.']
)
end
it 'handles class_eval with implicit receiver' do
inspect_source(cop, ['module A',
' class_eval do',
' def some_method',
' implement 1',
' end',
' def some_method',
' implement 2',
' end',
' end',
'end'], 'test.rb')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['Method `A#some_method` is defined at both test.rb:3 and test.rb:6.']
)
end
it 'ignores method definitions in RSpec `describe` blocks' do
inspect_source(cop,
['describe "something" do',
' def some_method',
' implement 1',
' end',
' def some_method',
' implement 2',
' end',
'end'], 'test.rb')
expect(cop.offenses).to be_empty
end
it 'ignores Class.new blocks which are assigned to local variables' do
inspect_source(cop, ['a = Class.new do',
' def foo',
' end',
'end',
'b = Class.new do',
' def foo',
' end',
'end'])
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/duplicated_key_spec.rb 0000664 0000000 0000000 00000007454 13070542236 0025626 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::DuplicatedKey do
subject(:cop) { described_class.new }
context 'When there is a duplicated key in the hash literal' do
let(:source) do
"hash = { 'otherkey' => 'value', 'key' => 'value', 'key' => 'hi' }"
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Duplicated key in hash literal.')
expect(cop.highlights).to eq ["'key'"]
end
end
context 'When there are two duplicated keys in a hash' do
let(:source) do
"hash = { fruit: 'apple', veg: 'kale', veg: 'cuke', fruit: 'orange' }"
end
it 'registers two offenses' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(2)
expect(cop.messages).to eq(['Duplicated key in hash literal.'] * 2)
expect(cop.highlights).to eq %w[veg fruit]
end
end
context 'When a key is duplicated three times in a hash literal' do
let(:source) do
'hash = { 1 => 2, 1 => 3, 1 => 4 }'
end
it 'registers two offenses' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(2)
expect(cop.messages).to eq(['Duplicated key in hash literal.'] * 2)
expect(cop.highlights).to eq %w[1 1]
end
end
context 'When there is no duplicated key in the hash' do
let(:source) do
"hash = { ['one', 'two'] => ['hello, bye'], ['two'] => ['yes, no'] }"
end
it 'does not register an offense' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
shared_examples :duplicated_literal_key do |key|
it "registers an offense for duplicated `#{key}` hash keys" do
inspect_source(cop, "hash = { #{key} => 1, #{key} => 4}")
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Duplicated key in hash literal.')
expect(cop.highlights).to eq [key]
end
end
it_behaves_like :duplicated_literal_key, '!true'
it_behaves_like :duplicated_literal_key, '"#{2}"'
it_behaves_like :duplicated_literal_key, '(1)'
it_behaves_like :duplicated_literal_key, '(false && true)'
it_behaves_like :duplicated_literal_key, '(false <=> true)'
it_behaves_like :duplicated_literal_key, '(false or true)'
it_behaves_like :duplicated_literal_key, '[1, 2, 3]'
it_behaves_like :duplicated_literal_key, '{ :a => 1, :b => 2 }'
it_behaves_like :duplicated_literal_key, '{ a: 1, b: 2 }'
it_behaves_like :duplicated_literal_key, '/./'
it_behaves_like :duplicated_literal_key, '%r{abx}ixo'
it_behaves_like :duplicated_literal_key, '1.0'
it_behaves_like :duplicated_literal_key, '1'
it_behaves_like :duplicated_literal_key, 'false'
it_behaves_like :duplicated_literal_key, 'nil'
it_behaves_like :duplicated_literal_key, "'str'"
shared_examples :duplicated_non_literal_key do |key|
it "does not register an offense for duplicated `#{key}` hash keys" do
inspect_source(cop, "hash = { #{key} => 1, #{key} => 4}")
expect(cop.offenses).to be_empty
end
end
it_behaves_like :duplicated_non_literal_key, '"#{some_method_call}"'
it_behaves_like :duplicated_non_literal_key, '(x && false)'
it_behaves_like :duplicated_non_literal_key, '(x == false)'
it_behaves_like :duplicated_non_literal_key, '(x or false)'
it_behaves_like :duplicated_non_literal_key, '[some_method_call]'
it_behaves_like :duplicated_non_literal_key, '{ :sym => some_method_call }'
it_behaves_like :duplicated_non_literal_key, '{ some_method_call => :sym }'
it_behaves_like :duplicated_non_literal_key, '/.#{some_method_call}/'
it_behaves_like :duplicated_non_literal_key, '%r{abx#{foo}}ixo'
it_behaves_like :duplicated_non_literal_key, 'some_method_call'
it_behaves_like :duplicated_non_literal_key, 'some_method_call(x, y)'
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/each_with_object_argument_spec.rb 0000664 0000000 0000000 00000002443 13070542236 0030014 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::EachWithObjectArgument do
subject(:cop) { described_class.new }
it 'registers an offense for fixnum argument' do
inspect_source(cop, 'collection.each_with_object(0) { |e, a| a + e }')
expect(cop.messages)
.to eq(['The argument to each_with_object can not be immutable.'])
end
it 'registers an offense for float argument' do
inspect_source(cop, 'collection.each_with_object(0.1) { |e, a| a + e }')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for bignum argument' do
inspect_source(cop,
'c.each_with_object(100000000000000000000) { |e, o| o + e }')
expect(cop.offenses.size).to eq(1)
end
it 'accepts a variable argument' do
inspect_source(cop, 'collection.each_with_object(x) { |e, a| a.add(e) }')
expect(cop.offenses).to be_empty
end
it 'accepts two arguments' do
# Two arguments would indicate that this is not Enumerable#each_with_object.
inspect_source(cop, 'collection.each_with_object(1, 2) { |e, a| a.add(e) }')
expect(cop.offenses).to be_empty
end
it 'accepts a string argument' do
inspect_source(cop,
"collection.each_with_object('') { |e, a| a << e.to_s }")
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/else_layout_spec.rb 0000664 0000000 0000000 00000003034 13070542236 0025153 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::ElseLayout do
subject(:cop) { described_class.new }
it 'registers an offense for expr on same line as else' do
inspect_source(cop,
['if something',
' test',
'else ala',
' something',
' test',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'accepts proper else' do
inspect_source(cop,
['if something',
' test',
'else',
' something',
' test',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts single-expr else regardless of layout' do
inspect_source(cop,
['if something',
' test',
'else bala',
'end'])
expect(cop.offenses).to be_empty
end
it 'can handle elsifs' do
inspect_source(cop,
['if something',
' test',
'elsif something',
' bala',
'else ala',
' something',
' test',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'handles ternary ops' do
inspect_source(cop, 'x ? a : b')
expect(cop.offenses).to be_empty
end
it 'handles modifier forms' do
inspect_source(cop, 'x if something')
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/empty_ensure_spec.rb 0000664 0000000 0000000 00000002040 13070542236 0025341 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::EmptyEnsure do
subject(:cop) { described_class.new }
it 'registers an offense for empty ensure' do
inspect_source(cop,
['begin',
' something',
'ensure',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'autocorrects for empty ensure' do
corrected = autocorrect_source(cop,
['begin',
' something',
'ensure',
'end'])
expect(corrected).to eq([
'begin',
' something',
'',
'end'
].join("\n"))
end
it 'does not register an offense for non-empty ensure' do
inspect_source(cop,
['begin',
' something',
' return',
'ensure',
' file.close',
'end'])
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/empty_expression_spec.rb 0000664 0000000 0000000 00000005043 13070542236 0026245 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::EmptyExpression, :config do
subject(:cop) { described_class.new(config) }
before do
inspect_source(cop, source)
end
shared_examples 'code with offense' do |code, expected = nil|
context "when checking #{code}" do
let(:source) { code }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq([message])
end
if expected
it 'auto-corrects' do
expect(autocorrect_source(cop, code)).to eq(expected)
end
else
it 'does not auto-correct' do
expect(autocorrect_source(cop, code)).to eq(code)
end
end
end
end
shared_examples 'code without offense' do |code|
let(:source) { code }
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
let(:message) { described_class::MSG }
context 'when used as a standalone expression' do
it_behaves_like 'code with offense',
'()'
context 'with nested empty expressions' do
it_behaves_like 'code with offense',
'(())'
end
end
context 'when used in a condition' do
it_behaves_like 'code with offense',
'if (); end'
it_behaves_like 'code with offense',
['if foo',
' 1',
'elsif ()',
' 2',
'end'].join("\n")
it_behaves_like 'code with offense',
['case ()',
'when :foo then 1',
'end'].join("\n")
it_behaves_like 'code with offense',
['case foo',
'when () then 1',
'end'].join("\n")
it_behaves_like 'code with offense',
'() ? true : false'
it_behaves_like 'code with offense',
'foo ? () : bar'
end
context 'when used as a return value' do
it_behaves_like 'code with offense',
['def foo',
' ()',
'end'].join("\n")
it_behaves_like 'code with offense',
['if foo',
' ()',
'end'].join("\n")
it_behaves_like 'code with offense',
['case foo',
'when :bar then ()',
'end'].join("\n")
end
context 'when used as an assignment' do
it_behaves_like 'code with offense',
'foo = ()'
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/empty_interpolation_spec.rb 0000664 0000000 0000000 00000001725 13070542236 0026740 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::EmptyInterpolation do
subject(:cop) { described_class.new }
it 'registers an offense for #{} in interpolation' do
inspect_source(cop, '"this is the #{}"')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['#{}'])
end
it 'registers an offense for #{ } in interpolation' do
inspect_source(cop, '"this is the #{ }"')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['#{ }'])
end
it 'accepts non-empty interpolation' do
inspect_source(cop, '"this is #{top} silly"')
expect(cop.offenses).to be_empty
end
it 'autocorrects empty interpolation' do
new_source = autocorrect_source(cop, '"this is the #{}"')
expect(new_source).to eq('"this is the "')
end
it 'autocorrects empty interpolation containing a space' do
new_source = autocorrect_source(cop, '"this is the #{ }"')
expect(new_source).to eq('"this is the "')
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/empty_when_spec.rb 0000664 0000000 0000000 00000007660 13070542236 0025016 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::EmptyWhen, :config do
subject(:cop) { described_class.new(config) }
before do
inspect_source(cop, source)
end
shared_examples 'code with offense' do |code, expected = nil|
context "when checking #{code}" do
let(:source) { code }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq([message])
end
if expected
it 'auto-corrects' do
expect(autocorrect_source(cop, code)).to eq(expected)
end
else
it 'does not auto-correct' do
expect(autocorrect_source(cop, code)).to eq(code)
end
end
end
end
shared_examples 'code without offense' do |code|
let(:source) { code }
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
let(:message) { described_class::MSG }
context 'when a `when` body is missing' do
it_behaves_like 'code with offense',
['case foo',
'when :bar then 1',
'when :baz # nothing',
'end'].join("\n")
it_behaves_like 'code with offense',
['case foo',
'when :bar then 1',
'when :baz # nothing',
'else 3',
'end'].join("\n")
it_behaves_like 'code with offense',
['case foo',
'when :bar then 1',
'when :baz then # nothing',
'end'].join("\n")
it_behaves_like 'code with offense',
['case foo',
'when :bar then 1',
'when :baz then # nothing',
'else 3',
'end'].join("\n")
it_behaves_like 'code with offense',
['case foo',
'when :bar',
' 1',
'when :baz',
' # nothing',
'end'].join("\n")
it_behaves_like 'code with offense',
['case foo',
'when :bar',
' 1',
'when :baz',
' # nothing',
'else',
' 3',
'end'].join("\n")
it_behaves_like 'code with offense',
['case',
'when :bar',
' 1',
'when :baz',
' # nothing',
'else',
' 3',
'end'].join("\n")
end
context 'when a `when` body is present' do
it_behaves_like 'code without offense',
['case foo',
'when :bar then 1',
'when :baz then 2',
'end'].join("\n")
it_behaves_like 'code without offense',
['case foo',
'when :bar then 1',
'when :baz then 2',
'else 3',
'end'].join("\n")
it_behaves_like 'code without offense',
['case foo',
'when :bar',
' 1',
'when :baz',
' 2',
'end'].join("\n")
it_behaves_like 'code without offense',
['case foo',
'when :bar',
' 1',
'when :baz',
' 2',
'else',
' 3',
'end'].join("\n")
it_behaves_like 'code without offense',
['case',
'when :bar',
' 1',
'when :baz',
' 2',
'else',
' 3',
'end'].join("\n")
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/end_alignment_spec.rb 0000664 0000000 0000000 00000031670 13070542236 0025441 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::EndAlignment, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) do
{ 'EnforcedStyleAlignWith' => 'keyword', 'AutoCorrect' => true }
end
include_examples 'misaligned', '', 'class', 'Test', ' end'
include_examples 'misaligned', '', 'module', 'Test', ' end'
include_examples 'misaligned', '', 'if', 'test', ' end'
include_examples 'misaligned', '', 'unless', 'test', ' end'
include_examples 'misaligned', '', 'while', 'test', ' end'
include_examples 'misaligned', '', 'until', 'test', ' end'
include_examples 'misaligned', '', 'case', 'a when b', ' end'
include_examples 'aligned', "\xef\xbb\xbfclass", 'Test', 'end'
include_examples 'aligned', 'class', 'Test', 'end'
include_examples 'aligned', 'module', 'Test', 'end'
include_examples 'aligned', 'if', 'test', 'end'
include_examples 'aligned', 'unless', 'test', 'end'
include_examples 'aligned', 'while', 'test', 'end'
include_examples 'aligned', 'until', 'test', 'end'
include_examples 'aligned', 'case', 'a when b', 'end'
include_examples 'misaligned', 'puts 1; ', 'class', 'Test', 'end'
include_examples 'misaligned', 'puts 1; ', 'module', 'Test', 'end'
include_examples 'misaligned', 'puts 1; ', 'if', 'test', 'end'
include_examples 'misaligned', 'puts 1; ', 'unless', 'test', 'end'
include_examples 'misaligned', 'puts 1; ', 'while', 'test', 'end'
include_examples 'misaligned', 'puts 1; ', 'until', 'test', 'end'
include_examples 'misaligned', 'puts 1; ', 'case', 'a when b', 'end'
include_examples 'aligned', 'puts 1; class', 'Test', ' end'
include_examples 'aligned', 'puts 1; module', 'Test', ' end'
include_examples 'aligned', 'puts 1; if', 'Test', ' end'
include_examples 'aligned', 'puts 1; unless', 'Test', ' end'
include_examples 'aligned', 'puts 1; while', 'Test', ' end'
include_examples 'aligned', 'puts 1; until', 'Test', ' end'
include_examples 'aligned', 'puts 1; case', 'a when b', ' end'
it 'can handle ternary if' do
inspect_source(cop, 'a = cond ? x : y')
expect(cop.offenses).to be_empty
end
it 'can handle modifier if' do
inspect_source(cop, 'a = x if cond')
expect(cop.offenses).to be_empty
end
context 'when EnforcedStyleAlignWith is start_of_line' do
let(:cop_config) do
{ 'EnforcedStyleAlignWith' => 'start_of_line', 'AutoCorrect' => true }
end
include_examples 'misaligned', '', 'class Test', '', ' end'
include_examples 'misaligned', '', 'module Test', '', ' end'
include_examples 'misaligned', '', 'if test', '', ' end'
include_examples 'misaligned', '', 'unless test', '', ' end'
include_examples 'misaligned', '', 'while test', '', ' end'
include_examples 'misaligned', '', 'until test', '', ' end'
include_examples 'misaligned', '', 'case a when b', '', ' end'
include_examples 'aligned', 'puts 1; class', 'Test', 'end'
include_examples 'aligned', 'puts 1; module', 'Test', 'end'
include_examples 'aligned', 'puts 1; if', 'test', 'end'
include_examples 'aligned', 'puts 1; unless', 'test', 'end'
include_examples 'aligned', 'puts 1; while', 'test', 'end'
include_examples 'aligned', 'puts 1; until', 'test', 'end'
include_examples 'aligned', 'puts 1; case', 'a when b', 'end'
include_examples 'misaligned', '', 'puts 1; class Test', '', ' end'
include_examples 'misaligned', '', 'puts 1; module Test', '', ' end'
include_examples 'misaligned', '', 'puts 1; if test', '', ' end'
include_examples 'misaligned', '', 'puts 1; unless test', '', ' end'
include_examples 'misaligned', '', 'puts 1; while test', '', ' end'
include_examples 'misaligned', '', 'puts 1; until test', '', ' end'
include_examples 'misaligned', '', 'puts 1; case a when b', '', ' end'
end
context 'when EnforcedStyleAlignWith is variable' do
# same as 'EnforcedStyleAlignWith' => 'keyword',
# as long as assignments or `case` are not involved
let(:cop_config) do
{ 'EnforcedStyleAlignWith' => 'variable', 'AutoCorrect' => true }
end
include_examples 'misaligned', '', 'class', 'Test', ' end'
include_examples 'misaligned', '', 'module', 'Test', ' end'
include_examples 'misaligned', '', 'if', 'test', ' end'
include_examples 'misaligned', '', 'unless', 'test', ' end'
include_examples 'misaligned', '', 'while', 'test', ' end'
include_examples 'misaligned', '', 'until', 'test', ' end'
include_examples 'misaligned', '', 'case', 'a when b', ' end'
include_examples 'aligned', 'class', 'Test', 'end'
include_examples 'aligned', 'module', 'Test', 'end'
include_examples 'aligned', 'if', 'test', 'end'
include_examples 'aligned', 'unless', 'test', 'end'
include_examples 'aligned', 'while', 'test', 'end'
include_examples 'aligned', 'until', 'test', 'end'
include_examples 'aligned', 'case', 'a when b', 'end'
include_examples 'misaligned', 'puts 1; ', 'class', 'Test', 'end'
include_examples 'misaligned', 'puts 1; ', 'module', 'Test', 'end'
include_examples 'misaligned', 'puts 1; ', 'if', 'test', 'end'
include_examples 'misaligned', 'puts 1; ', 'unless', 'test', 'end'
include_examples 'misaligned', 'puts 1; ', 'while', 'test', 'end'
include_examples 'misaligned', 'puts 1; ', 'until', 'test', 'end'
include_examples 'misaligned', 'puts 1; ', 'case', 'a when b', 'end'
include_examples 'aligned', 'puts 1; class', 'Test', ' end'
include_examples 'aligned', 'puts 1; module', 'Test', ' end'
include_examples 'aligned', 'puts 1; if', 'Test', ' end'
include_examples 'aligned', 'puts 1; unless', 'Test', ' end'
include_examples 'aligned', 'puts 1; while', 'Test', ' end'
include_examples 'aligned', 'puts 1; until', 'Test', ' end'
include_examples 'aligned', 'puts 1; case', 'a when b', ' end'
end
context 'correct + opposite' do
let(:source) do
['x = if a',
' a1',
' end',
'y = if b',
' b1',
'end']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.messages.first)
.to eq('`end` at 6, 0 is not aligned with `if` at 4, 4.')
expect(cop.highlights.first).to eq('end')
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'does auto-correction' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq(['x = if a',
' a1',
' end',
'y = if b',
' b1',
' end'].join("\n"))
end
end
context 'when end is preceded by something else than whitespace' do
let(:source) do
['module A',
'puts a end']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.messages.first)
.to eq('`end` at 2, 7 is not aligned with `module` at 1, 0.')
expect(cop.highlights.first).to eq('end')
end
it "doesn't auto-correct" do
expect(autocorrect_source(cop, source))
.to eq(source.join("\n"))
expect(cop.offenses.map(&:corrected?)).to eq [false]
end
end
context 'case as argument' do
context 'when EnforcedStyleAlignWith is keyword' do
let(:cop_config) do
{ 'EnforcedStyleAlignWith' => 'keyword', 'AutoCorrect' => true }
end
include_examples 'aligned', 'test case', 'a when b', ' end'
include_examples 'misaligned', 'test ', 'case', 'a when b', 'end'
end
context 'when EnforcedStyleAlignWith is variable' do
let(:cop_config) do
{ 'EnforcedStyleAlignWith' => 'variable', 'AutoCorrect' => true }
end
include_examples 'aligned', 'test case', 'a when b', 'end'
include_examples 'misaligned', '', 'test case', 'a when b', ' end'
end
context 'when EnforcedStyleAlignWith is start_of_line' do
let(:cop_config) do
{ 'EnforcedStyleAlignWith' => 'start_of_line', 'AutoCorrect' => true }
end
include_examples 'aligned', 'test case a when b', '', 'end'
include_examples 'misaligned', '', 'test case a when b', '', ' end'
end
end
context 'regarding assignment' do
context 'when EnforcedStyleAlignWith is keyword' do
include_examples 'misaligned', 'var = ', 'if', 'test', 'end'
include_examples 'misaligned', 'var = ', 'unless', 'test', 'end'
include_examples 'misaligned', 'var = ', 'while', 'test', 'end'
include_examples 'misaligned', 'var = ', 'until', 'test', 'end'
include_examples 'misaligned', 'var = ', 'case', 'a when b', 'end'
include_examples 'aligned', 'var = if', 'test', ' end'
include_examples 'aligned', 'var = unless', 'test', ' end'
include_examples 'aligned', 'var = while', 'test', ' end'
include_examples 'aligned', 'var = until', 'test', ' end'
include_examples 'aligned', 'var = case', 'a when b', ' end'
end
context 'when EnforcedStyleAlignWith is variable' do
let(:cop_config) do
{ 'EnforcedStyleAlignWith' => 'variable', 'AutoCorrect' => true }
end
include_examples 'aligned', 'var = if', 'test', 'end'
include_examples 'aligned', 'var = unless', 'test', 'end'
include_examples 'aligned', 'var = while', 'test', 'end'
include_examples 'aligned', 'var = until', 'test', 'end'
include_examples 'aligned', 'var = until', 'test', 'end.ab.join("")'
include_examples 'aligned', 'var = until', 'test', 'end.ab.tap {}'
include_examples 'aligned', 'var = case', 'a when b', 'end'
include_examples 'aligned', "var =\n if", 'test', ' end'
include_examples 'misaligned', '', 'var = if', 'test', ' end'
include_examples 'misaligned', '', 'var = unless', 'test', ' end'
include_examples 'misaligned', '', 'var = while', 'test', ' end'
include_examples 'misaligned', '', 'var = until', 'test', ' end'
include_examples 'misaligned', '', 'var = until', 'test', ' end.j'
include_examples 'misaligned', '', 'var = case', 'a when b', ' end'
include_examples 'aligned', '@var = if', 'test', 'end'
include_examples 'aligned', '@@var = if', 'test', 'end'
include_examples 'aligned', '$var = if', 'test', 'end'
include_examples 'aligned', 'CNST = if', 'test', 'end'
include_examples 'aligned', 'a, b = if', 'test', 'end'
include_examples 'aligned', 'var ||= if', 'test', 'end'
include_examples 'aligned', 'var &&= if', 'test', 'end'
include_examples 'aligned', 'var += if', 'test', 'end'
include_examples 'aligned', 'h[k] = if', 'test', 'end'
include_examples 'aligned', 'h.k = if', 'test', 'end'
include_examples 'misaligned', '', '@var = if', 'test', ' end'
include_examples 'misaligned', '', '@@var = if', 'test', ' end'
include_examples 'misaligned', '', '$var = if', 'test', ' end'
include_examples 'misaligned', '', 'CNST = if', 'test', ' end'
include_examples 'misaligned', '', 'a, b = if', 'test', ' end'
include_examples 'misaligned', '', 'var ||= if', 'test', ' end'
include_examples 'misaligned', '', 'var &&= if', 'test', ' end'
include_examples 'misaligned', '', 'var += if', 'test', ' end'
include_examples 'misaligned', '', 'h[k] = if', 'test', ' end'
include_examples 'misaligned', '', 'h.k = if', 'test', ' end'
end
end
context 'when EnforcedStyleAlignWith is start_of_line' do
let(:cop_config) do
{ 'EnforcedStyleAlignWith' => 'start_of_line', 'AutoCorrect' => true }
end
include_examples 'misaligned', '', 'var = if test', '', ' end'
include_examples 'misaligned', '', 'var = unless test', '', ' end'
include_examples 'misaligned', '', 'var = while test', '', ' end'
include_examples 'misaligned', '', 'var = until test', '', ' end'
include_examples 'misaligned', '', 'var = case a when b', '', ' end'
include_examples 'aligned', 'var = if', 'test', 'end'
include_examples 'aligned', 'var = unless', 'test', 'end'
include_examples 'aligned', 'var = while', 'test', 'end'
include_examples 'aligned', 'var = until', 'test', 'end'
include_examples 'aligned', 'var = case', 'a when b', 'end'
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/end_in_method_spec.rb 0000664 0000000 0000000 00000001250 13070542236 0025420 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::EndInMethod do
subject(:cop) { described_class.new }
it 'reports an offense for def with an END inside' do
src = ['def test',
' END { something }',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'reports an offense for defs with an END inside' do
src = ['def self.test',
' END { something }',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'accepts END outside of def(s)' do
src = 'END { something }'
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/ensure_return_spec.rb 0000664 0000000 0000000 00000001772 13070542236 0025535 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::EnsureReturn do
subject(:cop) { described_class.new }
it 'registers an offense for return in ensure' do
inspect_source(cop,
['begin',
' something',
'ensure',
' file.close',
' return',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'does not register an offense for return outside ensure' do
inspect_source(cop,
['begin',
' something',
' return',
'ensure',
' file.close',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not check when ensure block has no body' do
expect do
inspect_source(cop,
['begin',
' something',
'ensure',
'end'])
end.not_to raise_exception
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/float_out_of_range_spec.rb 0000664 0000000 0000000 00000002211 13070542236 0026456 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::FloatOutOfRange do
subject(:cop) { described_class.new }
before do
inspect_source(cop, source)
end
context 'on 0.0' do
let(:source) { '0.0' }
it "doesn't register an offense" do
expect(cop.offenses).to be_empty
end
end
context 'on tiny little itty bitty floats' do
let(:source) { '1.1e-100' }
it "doesn't register an offense" do
expect(cop.offenses).to be_empty
end
end
context 'on respectably sized floats' do
let(:source) { '55.7e89' }
it "doesn't register an offense" do
expect(cop.offenses).to be_empty
end
end
context 'on whopping big floats which tip the scales' do
let(:source) { '9.9999e999' }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Float out of range.'])
end
end
context 'on floats so close to zero that nobody can tell the difference' do
let(:source) { '1.0e-400' }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Float out of range.'])
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/format_parameter_mismatch_spec.rb 0000664 0000000 0000000 00000026725 13070542236 0030057 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::FormatParameterMismatch do
subject(:cop) { described_class.new }
shared_examples 'variables' do |variable|
it 'does not register an offense for % called on a variable' do
inspect_source(cop, ["#{variable} = '%s'",
"#{variable} % [foo]"])
expect(cop.messages).to be_empty
end
it 'does not register an offense for format called on a variable' do
inspect_source(cop, ["#{variable} = '%s'",
"format(#{variable}, foo)"])
expect(cop.messages).to be_empty
end
it 'does not register an offense for format called on a variable' do
inspect_source(cop, ["#{variable} = '%s'",
"sprintf(#{variable}, foo)"])
expect(cop.messages).to be_empty
end
end
it_behaves_like 'variables', 'CONST'
it_behaves_like 'variables', 'var'
it_behaves_like 'variables', '@var'
it_behaves_like 'variables', '@@var'
it_behaves_like 'variables', '$var'
it 'registers an offense when calling Kernel.format ' \
'and the fields do not match' do
inspect_source(cop, 'Kernel.format("%s %s", 1)')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
["Number of arguments (1) to `format` doesn't match the number of " \
'fields (2).']
)
end
it 'registers an offense when calling Kernel.sprintf ' \
'and the fields do not match' do
inspect_source(cop, 'Kernel.sprintf("%s %s", 1)')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
["Number of arguments (1) to `sprintf` doesn't match the number of " \
'fields (2).']
)
end
it 'registers an offense when there are less arguments than expected' do
inspect_source(cop, 'format("%s %s", 1)')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
["Number of arguments (1) to `format` doesn't match the number of " \
'fields (2).']
)
end
it 'registers an offense when there are more arguments than expected' do
inspect_source(cop, 'format("%s %s", 1, 2, 3)')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
["Number of arguments (3) to `format` doesn't match the number of " \
'fields (2).']
)
end
it 'does not register an offense when arguments and fields match' do
inspect_source(cop, 'format("%s %d %i", 1, 2, 3)')
expect(cop.offenses).to be_empty
end
it 'correctly ignores double percent' do
inspect_source(cop, "format('%s %s %% %s %%%% %%%%%%', 1, 2, 3)")
expect(cop.offenses).to be_empty
end
it 'constants do not register offenses' do
inspect_source(cop, 'format(A_CONST, 1, 2, 3)')
expect(cop.offenses).to be_empty
end
it 'registers offense with sprintf' do
inspect_source(cop, 'sprintf("%s %s", 1, 2, 3)')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
["Number of arguments (3) to `sprintf` doesn't match the number of " \
'fields (2).']
)
end
it 'correctly parses different sprintf formats' do
inspect_source(cop,
'sprintf("%020x%+g:% g %%%#20.8x %#.0e", 1, 2, 3, 4, 5)')
expect(cop.offenses).to be_empty
end
it 'registers an offense for String#%' do
inspect_source(cop, '"%s %s" % [1, 2, 3]')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
["Number of arguments (3) to `String#%` doesn't match the number of " \
'fields (2).']
)
end
it 'does not register offense for `String#%` when arguments, fields match' do
inspect_source(cop, '"%s %s" % [1, 2]')
expect(cop.offenses).to be_empty
end
it 'does not register an offense when single argument is a hash' do
inspect_source(cop, 'puts "%s" % {"a" => 1}')
expect(cop.offenses).to be_empty
end
it 'does not register an offense when single argument is not an array' do
inspect_source(cop, 'puts "%s" % 42')
expect(cop.offenses).to be_empty
inspect_source(cop, 'puts "%s" % "1"')
expect(cop.offenses).to be_empty
inspect_source(cop, 'puts "%s" % 1.2')
expect(cop.offenses).to be_empty
inspect_source(cop, 'puts "%s" % :a')
expect(cop.offenses).to be_empty
inspect_source(cop, 'puts "%s" % CONST')
expect(cop.offenses).to be_empty
end
context 'when splat argument is present' do
it 'does not register an offense when args count is less than expected' do
inspect_source(cop, '"%s, %s, %s" % [1, *arr]')
expect(cop.offenses).to be_empty
inspect_source(cop, 'format("%s, %s, %s", 1, *arr)')
expect(cop.offenses).to be_empty
inspect_source(cop, 'sprintf("%s, %s, %s", 1, *arr)')
expect(cop.offenses).to be_empty
end
it 'does register an offense when args count is more than expected' do
inspect_source(cop, 'puts "%s, %s, %s" % [1, 2, 3, 4, *arr]')
expect(cop.offenses).not_to be_empty
inspect_source(cop, 'format("%s, %s, %s", 1, 2, 3, 4, *arr)')
expect(cop.offenses).not_to be_empty
inspect_source(cop, 'sprintf("%s, %s, %s", 1, 2, 3, 4, *arr)')
expect(cop.offenses).not_to be_empty
end
end
context 'when multiple arguments are called for' do
context 'and a single variable argument is passed' do
it 'does not register an offense' do
# the variable could evaluate to an array
inspect_source(cop, 'puts "%s %s" % var')
expect(cop.offenses).to be_empty
end
end
context 'and a single send node is passed' do
it 'does not register an offense' do
inspect_source(cop, 'puts "%s %s" % ("ab".chars)')
expect(cop.offenses).to be_empty
end
end
end
context 'when format is not a string literal' do
it 'does not register an offense' do
inspect_source(cop, 'puts str % [1, 2]')
expect(cop.offenses).to be_empty
end
end
# Regression: https://github.com/bbatsov/rubocop/issues/3869
context 'when passed an empty array' do
it 'does not register an offense' do
inspect_source(cop, "'%' % []")
expect(cop.offenses).to be_empty
end
end
it 'ignores percent right next to format string' do
inspect_source(cop, 'format("%0.1f%% percent", 22.5)')
expect(cop.offenses).to be_empty
end
it 'accepts an extra argument for dynamic width' do
inspect_source(cop, 'format("%*d", max_width, id)')
expect(cop.offenses).to be_empty
end
it 'registers an offense if extra argument for dynamic width not given' do
inspect_source(cop, 'format("%*d", id)')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(["Number of arguments (1) to `format` doesn't " \
'match the number of fields (2).'])
end
it 'accepts an extra arg for dynamic width with other preceding flags' do
inspect_source(cop, 'format("%0*x", max_width, id)')
expect(cop.offenses).to be_empty
end
it 'accepts an extra arg for dynamic width with other following flags' do
inspect_source(cop, 'format("%*0x", max_width, id)')
expect(cop.offenses).to be_empty
end
it 'does not register an offense argument is the result of a message send' do
inspect_source(cop, '"%s" % "a b c".gsub(" ", "_")')
expect(cop.offenses).to be_empty
inspect_source(cop, 'format("%s", "a b c".gsub(" ", "_"))')
expect(cop.offenses).to be_empty
end
it 'does not register an offense when using named parameters' do
inspect_source(cop, '"foo %{bar} baz" % { bar: 42 }')
expect(cop.offenses).to be_empty
end
it 'identifies correctly digits for spacing in format' do
inspect_source(cop, '"duration: %10.fms" % 42')
expect(cop.offenses).to be_empty
end
it 'finds faults even when the string looks like a HEREDOC' do
# heredocs are ignored at the moment
inspect_source(cop, 'format("<< %s bleh", 1, 2)')
expect(cop.offenses.size).to eq(1)
end
it 'does not register an offense for sprintf with splat argument' do
inspect_source(cop, 'sprintf("%d%d", *test)')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for format with splat argument' do
inspect_source(cop, 'format("%d%d", *test)')
expect(cop.offenses).to be_empty
end
context 'on format with %{} interpolations' do
context 'and 1 argument' do
it 'does not register an offense' do
inspect_source(cop, ["params = { y: '2015', m: '01', d: '01' }",
"puts format('%{y}-%{m}-%{d}', params)"])
expect(cop.offenses).to be_empty
end
end
context 'and multiple arguments' do
it 'registers an offense' do
inspect_source(cop, ["params = { y: '2015', m: '01', d: '01' }",
"puts format('%{y}-%{m}-%{d}', 2015, 1, 1)"])
expect(cop.messages).to eq(['Number of arguments (3) to `format` ' \
"doesn't match the number of fields (1)."])
end
end
end
context 'on format with %<> interpolations' do
context 'and 1 argument' do
it 'does not register an offense' do
inspect_source(cop, ["params = { y: '2015', m: '01', d: '01' }",
"puts format('%d-%d-%d', params)"])
expect(cop.offenses).to be_empty
end
end
context 'and multiple arguments' do
it 'registers an offense' do
inspect_source(cop, ["params = { y: '2015', m: '01', d: '01' }",
"puts format('%d-%d-%d', 2015, 1, 1)"])
expect(cop.messages).to eq(['Number of arguments (3) to `format` ' \
"doesn't match the number of fields (1)."])
end
end
end
it 'finds the correct number of fields' do
expect(''.scan(described_class::FIELD_REGEX).size)
.to eq(0)
expect('%s'.scan(described_class::FIELD_REGEX).size)
.to eq(1)
expect('%s %s'.scan(described_class::FIELD_REGEX).size)
.to eq(2)
expect('%s %s %%'.scan(described_class::FIELD_REGEX).size)
.to eq(3)
expect('%s %s %%'.scan(described_class::FIELD_REGEX).size)
.to eq(3)
expect('% d'.scan(described_class::FIELD_REGEX).size)
.to eq(1)
expect('%+d'.scan(described_class::FIELD_REGEX).size)
.to eq(1)
expect('%d'.scan(described_class::FIELD_REGEX).size)
.to eq(1)
expect('%+o'.scan(described_class::FIELD_REGEX).size)
.to eq(1)
expect('%#o'.scan(described_class::FIELD_REGEX).size)
.to eq(1)
expect('%.0e'.scan(described_class::FIELD_REGEX).size)
.to eq(1)
expect('%#.0e'.scan(described_class::FIELD_REGEX).size)
.to eq(1)
expect('% 020d'.scan(described_class::FIELD_REGEX).size)
.to eq(1)
expect('%20d'.scan(described_class::FIELD_REGEX).size)
.to eq(1)
expect('%+20d'.scan(described_class::FIELD_REGEX).size)
.to eq(1)
expect('%020d'.scan(described_class::FIELD_REGEX).size)
.to eq(1)
expect('%+020d'.scan(described_class::FIELD_REGEX).size)
.to eq(1)
expect('% 020d'.scan(described_class::FIELD_REGEX).size)
.to eq(1)
expect('%-20d'.scan(described_class::FIELD_REGEX).size)
.to eq(1)
expect('%-+20d'.scan(described_class::FIELD_REGEX).size)
.to eq(1)
expect('%- 20d'.scan(described_class::FIELD_REGEX).size)
.to eq(1)
expect('%020x'.scan(described_class::FIELD_REGEX).size)
.to eq(1)
expect('%#20.8x'.scan(described_class::FIELD_REGEX).size)
.to eq(1)
expect('%+g:% g:%-g'.scan(described_class::FIELD_REGEX).size)
.to eq(3)
expect('%+-d'.scan(described_class::FIELD_REGEX).size) # multiple flags
.to eq(1)
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/handle_exceptions_spec.rb 0000664 0000000 0000000 00000001434 13070542236 0026324 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::HandleExceptions do
subject(:cop) { described_class.new }
it 'registers an offense for empty rescue block' do
inspect_source(cop,
['begin',
' something',
'rescue',
' #do nothing',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Do not suppress exceptions.'])
end
it 'does not register an offense for rescue with body' do
inspect_source(cop,
['begin',
' something',
' return',
'rescue',
' file.close',
'end'])
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/implicit_string_concatenation_spec.rb 0000664 0000000 0000000 00000005732 13070542236 0030742 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::ImplicitStringConcatenation do
subject(:cop) { described_class.new }
before do
inspect_source(cop, source)
end
context 'on a single string literal' do
let(:source) { 'abc' }
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
context 'on adjacent string literals on the same line' do
let(:source) { 'class A; "abc" "def"; end' }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Combine "abc" and "def" into a single ' \
'string literal, rather than using ' \
'implicit string concatenation.'])
expect(cop.highlights).to eq(['"abc" "def"'])
end
end
context 'on adjacent string literals on different lines' do
let(:source) { "array = [\n 'abc'\\\n 'def'\n]" }
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
context 'when the string literals contain newlines' do
let(:source) { "def method; 'ab\nc' 'de\nf'; end" }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Combine "ab\nc" and "de\nf" into a ' \
'single string literal, rather than using ' \
'implicit string concatenation.'])
expect(cop.highlights).to eq(["'ab\nc' 'de\nf'"])
end
end
context 'on a string with interpolations' do
let(:source) { 'array = ["abc#{something}def#{something_else}"]' }
it 'does register an offense' do
expect(cop.offenses).to be_empty
end
end
context 'when inside an array' do
let(:source) { 'array = ["abc" "def"]' }
it 'notes that the strings could be separated by a comma instead' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Combine "abc" and "def" into a single ' \
'string literal, rather than using ' \
'implicit string concatenation. Or, if they' \
' were intended to be separate array ' \
'elements, separate them with a comma.'])
expect(cop.highlights).to eq(['"abc" "def"'])
end
end
context "when in a method call's argument list" do
let(:source) { 'method("abc" "def")' }
it 'notes that the strings could be separated by a comma instead' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Combine "abc" and "def" into a single ' \
'string literal, rather than using ' \
'implicit string concatenation. Or, if they' \
' were intended to be separate method ' \
'arguments, separate them with a comma.'])
expect(cop.highlights).to eq(['"abc" "def"'])
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/ineffective_access_modifier_spec.rb 0000664 0000000 0000000 00000005161 13070542236 0030317 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::IneffectiveAccessModifier do
subject(:cop) { described_class.new }
before do
inspect_source(cop, source)
end
context 'when `private` is applied to a class method' do
let(:source) do
['class C',
' private',
'',
' def self.method',
' puts "hi"',
' end',
'end']
end
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['`private` (on line 2) does not make singleton methods private. ' \
'Use `private_class_method` or `private` inside a `class << self` ' \
'block instead.']
)
expect(cop.highlights).to eq(['def'])
end
end
context 'when `protected` is applied to a class method' do
let(:source) do
['class C',
' protected',
'',
' def self.method',
' puts "hi"',
' end',
'end']
end
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['`protected` (on line 2) does not make singleton methods protected. ' \
'Use `protected` inside a `class << self` block instead.']
)
expect(cop.highlights).to eq(['def'])
end
end
context 'when `private_class_method` is used' do
let(:source) do
['class C',
' private',
'',
' def self.method',
' puts "hi"',
' end',
'',
' private_class_method :method',
'end']
end
it "doesn't register an offense" do
expect(cop.offenses).to be_empty
end
end
context 'when a `class << self` block is used' do
let(:source) do
['class C',
' private',
'',
' class << self',
' def self.method',
' puts "hi"',
' end',
' end',
'end']
end
it "doesn't register an offense" do
expect(cop.offenses).to be_empty
end
end
context 'when there is an intervening instance method' do
let(:source) do
['class C',
'',
' private',
'',
' def instance_method',
' end',
'',
' def self.method',
' puts "hi"',
' end',
'end']
end
it 'still registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['`private` (on line 3) does not make singleton methods private. ' \
'Use `private_class_method` or `private` inside a `class << self` ' \
'block instead.']
)
expect(cop.highlights).to eq(['def'])
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/inherit_exception_spec.rb 0000664 0000000 0000000 00000002452 13070542236 0026351 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::InheritException, :config do
subject(:cop) { described_class.new(config) }
shared_examples 'registers an offense' do |message|
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq([message])
end
end
shared_examples 'auto-correct' do |expected|
it 'auto-corrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(expected)
end
end
context 'when class inherits from `Exception`' do
let(:source) do
'class C < Exception; end'
end
context 'with enforced style set to `runtime_error`' do
let(:cop_config) { { 'EnforcedStyle' => 'runtime_error' } }
it_behaves_like 'registers an offense',
'Inherit from `RuntimeError` instead of `Exception`.'
it_behaves_like 'auto-correct', 'class C < RuntimeError; end'
end
context 'with enforced style set to `standard_error`' do
let(:cop_config) { { 'EnforcedStyle' => 'standard_error' } }
it_behaves_like 'registers an offense',
'Inherit from `StandardError` instead of `Exception`.'
it_behaves_like 'auto-correct', 'class C < StandardError; end'
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/invalid_character_literal_spec.rb 0000664 0000000 0000000 00000001640 13070542236 0030005 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::InvalidCharacterLiteral do
subject(:cop) { described_class.new }
# Is there a way to emit this warning without syntax error?
#
# $ ruby -w
# p(? )
# -:1: warning: invalid character syntax; use ?\s
# -:1: syntax error, unexpected '?', expecting ')'
# p(? )
# ^
#
# https://github.com/ruby/ruby/blob/v2_1_0/parse.y#L7276
# https://github.com/whitequark/parser/blob/v2.1.2/lib/parser/lexer.rl#L1660
context 'with a non-escaped whitespace character literal' do
let(:source) { 'p(? )' }
it 'registers an offense' do
pending 'Is there a way to emit this warning without syntax errors?'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Invalid character literal; use ?\s')
expect(cop.highlights).to eq([' '])
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/literal_in_condition_spec.rb 0000664 0000000 0000000 00000011103 13070542236 0027012 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::LiteralInCondition do
subject(:cop) { described_class.new }
%w(1 2.0 [1] {} :sym :"#{a}").each do |lit|
it "registers an offense for literal #{lit} in if" do
inspect_source(cop,
["if #{lit}",
' top',
'end'])
expect(cop.offenses.size).to eq(1)
end
it "registers an offense for literal #{lit} in while" do
inspect_source(cop,
["while #{lit}",
' top',
'end'])
expect(cop.offenses.size).to eq(1)
end
it "registers an offense for literal #{lit} in post-loop while" do
inspect_source(cop,
['begin',
' top',
"end while(#{lit})"])
expect(cop.offenses.size).to eq(1)
end
it "registers an offense for literal #{lit} in until" do
inspect_source(cop,
["until #{lit}",
' top',
'end'])
expect(cop.offenses.size).to eq(1)
end
it "registers an offense for literal #{lit} in post-loop until" do
inspect_source(cop,
['begin',
' top',
"end until #{lit}"])
expect(cop.offenses.size).to eq(1)
end
it "registers an offense for literal #{lit} in case" do
inspect_source(cop,
["case #{lit}",
'when x then top',
'end'])
expect(cop.offenses.size).to eq(1)
end
it "registers an offense for literal #{lit} in a when " \
'of a case without anything after case keyword' do
inspect_source(cop,
['case',
"when #{lit} then top",
'end'])
expect(cop.offenses.size).to eq(1)
end
it "accepts literal #{lit} in a when of a case with " \
'something after case keyword' do
inspect_source(cop,
['case x',
"when #{lit} then top",
'end'])
expect(cop.offenses).to be_empty
end
it "registers an offense for literal #{lit} in &&" do
inspect_source(cop,
["if x && #{lit}",
' top',
'end'])
expect(cop.offenses.size).to eq(1)
end
it "registers an offense for literal #{lit} in complex cond" do
inspect_source(cop,
["if x && !(a && #{lit}) && y && z",
' top',
'end'])
expect(cop.offenses.size).to eq(1)
end
it "registers an offense for literal #{lit} in !" do
inspect_source(cop,
["if !#{lit}",
' top',
'end'])
expect(cop.offenses.size).to eq(1)
end
it "registers an offense for literal #{lit} in complex !" do
inspect_source(cop,
["if !(x && (y && #{lit}))",
' top',
'end'])
expect(cop.offenses.size).to eq(1)
end
it "accepts literal #{lit} if it's not an and/or operand" do
inspect_source(cop,
["if test(#{lit})",
' top',
'end'])
expect(cop.offenses).to be_empty
end
it "accepts literal #{lit} in non-toplevel and/or" do
inspect_source(cop,
["if (a || #{lit}).something",
' top',
'end'])
expect(cop.offenses).to be_empty
end
end
it 'accepts array literal in case, if it has non-literal elements' do
inspect_source(cop,
['case [1, 2, x]',
'when [1, 2, 5] then top',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts array literal in case, if it has nested non-literal element' do
inspect_source(cop,
['case [1, 2, [x, 1]]',
'when [1, 2, 5] then top',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for case with a primitive array condition' do
inspect_source(cop,
['case [1, 2, [3, 4]]',
'when [1, 2, 5] then top',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'accepts dstr literal in case' do
inspect_source(cop,
['case "#{x}"',
'when [1, 2, 5] then top',
'end'])
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/literal_in_interpolation_spec.rb 0000664 0000000 0000000 00000013361 13070542236 0027723 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::LiteralInInterpolation do
subject(:cop) { described_class.new }
it 'accepts empty interpolation' do
inspect_source(cop, '"this is #{a} silly"')
expect(cop.offenses).to be_empty
end
it 'accepts interpolation of xstr' do
inspect_source(cop, '"this is #{`a`} silly"')
expect(cop.offenses).to be_empty
end
it 'accepts interpolation of irange where endpoints are not literals' do
inspect_source(cop, '"this is an irange: #{var1..var2}"')
expect(cop.offenses).to be_empty
end
it 'accepts interpolation of erange where endpoints are not literals' do
inspect_source(cop, '"this is an erange: #{var1...var2}"')
expect(cop.offenses).to be_empty
end
shared_examples 'literal interpolation' do |literal, expected = literal|
it "registers an offense for #{literal} in interpolation" do
inspect_source(cop, %("this is the \#{#{literal}}"))
expect(cop.offenses.size).to eq(1)
end
it "should have #{literal} as the message highlight" do
inspect_source(cop, %("this is the \#{#{literal}}"))
expect(cop.highlights).to eq([literal.to_s])
end
it "removes interpolation around #{literal}" do
corrected = autocorrect_source(cop, %("this is the \#{#{literal}}"))
expect(corrected).to eq(%("this is the #{expected}"))
end
it "removes interpolation around #{literal} when there is more text" do
corrected =
autocorrect_source(cop, %("this is the \#{#{literal}} literally"))
expect(corrected).to eq(%("this is the #{expected} literally"))
end
it "removes interpolation around multiple #{literal}" do
corrected =
autocorrect_source(cop,
%("some \#{#{literal}} with \#{#{literal}} too"))
expect(corrected).to eq(%("some #{expected} with #{expected} too"))
end
context 'when there is non-literal and literal interpolation' do
context 'when literal interpolation is before non-literal' do
it 'only remove interpolation around literal' do
corrected =
autocorrect_source(cop, %("this is \#{#{literal}} with \#{a} now"))
expect(corrected).to eq(%("this is #{expected} with \#{a} now"))
end
end
context 'when literal interpolation is after non-literal' do
it 'only remove interpolation around literal' do
corrected =
autocorrect_source(cop, %("this is \#{a} with \#{#{literal}} now"))
expect(corrected).to eq(%("this is \#{a} with #{expected} now"))
end
end
end
it "registers an offense only for final #{literal} in interpolation" do
inspect_source(cop, %("this is the \#{#{literal};#{literal}}"))
expect(cop.offenses.size).to eq(1)
end
end
it_behaves_like('literal interpolation', 1)
it_behaves_like('literal interpolation', -1)
it_behaves_like('literal interpolation', 1_123)
it_behaves_like('literal interpolation', 123_456_789_123_456_789)
it_behaves_like('literal interpolation', 1.2e-3)
it_behaves_like('literal interpolation', 0xaabb)
it_behaves_like('literal interpolation', 0o377)
it_behaves_like('literal interpolation', 2.0)
it_behaves_like('literal interpolation', '[]', '[]')
it_behaves_like('literal interpolation', '["a", "b"]', '[\"a\", \"b\"]')
it_behaves_like('literal interpolation', '{"a" => "b"}', '{\"a\" => \"b\"}')
it_behaves_like('literal interpolation', true)
it_behaves_like('literal interpolation', false)
it_behaves_like('literal interpolation', 'nil')
it_behaves_like('literal interpolation', ':symbol', 'symbol')
it_behaves_like('literal interpolation', ':"symbol"', 'symbol')
it_behaves_like('literal interpolation', 1..2)
it_behaves_like('literal interpolation', 1...2)
it 'handles nested interpolations when auto-correction' do
corrected = autocorrect_source(cop, %("this is \#{"\#{1}"} silly"))
# next iteration fixes this
expect(corrected).to eq %("this is \#{"1"} silly")
end
shared_examples 'special keywords' do |keyword|
it "accepts strings like #{keyword}" do
inspect_source(cop, %("this is \#{#{keyword}} silly"))
expect(cop.offenses).to be_empty
end
it "does not try to autocorrect strings like #{keyword}" do
corrected = autocorrect_source(cop, %("this is the \#{#{keyword}} silly"))
expect(corrected).to eq(%("this is the \#{#{keyword}} silly"))
end
it "registers an offense for interpolation after #{keyword}" do
inspect_source(cop, %("this is the \#{#{keyword}} \#{1}"))
expect(cop.offenses.size).to eq(1)
end
it "auto-corrects literal interpolation after #{keyword}" do
corrected = autocorrect_source(cop, %("this is the \#{#{keyword}} \#{1}"))
expect(corrected).to eq(%("this is the \#{#{keyword}} 1"))
end
end
it_behaves_like('special keywords', '__FILE__')
it_behaves_like('special keywords', '__LINE__')
it_behaves_like('special keywords', '__END__')
it_behaves_like('special keywords', '__ENCODING__')
shared_examples 'non-special string literal interpolation' do |string|
it "registers an offense for #{string}" do
inspect_source(cop, %("this is the \#{#{string}}"))
expect(cop.offenses.size).to eq(1)
end
it "should have #{string} in the message highlight" do
inspect_source(cop, %("this is the \#{#{string}}"))
expect(cop.highlights).to eq([string])
end
it "should remove the interpolation and quotes around #{string}" do
corrected = autocorrect_source(cop, %("this is the \#{#{string}}"))
expect(corrected).to eq(%("this is the #{string.gsub(/'|"/, '')}"))
end
end
it_behaves_like('non-special string literal interpolation', %('foo'))
it_behaves_like('non-special string literal interpolation', %("foo"))
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/loop_spec.rb 0000664 0000000 0000000 00000001262 13070542236 0023600 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::Loop do
subject(:cop) { described_class.new }
it 'registers an offense for begin/end/while' do
inspect_source(cop, 'begin something; top; end while test')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for begin/end/until' do
inspect_source(cop, 'begin something; top; end until test')
expect(cop.offenses.size).to eq(1)
end
it 'accepts normal while' do
inspect_source(cop, 'while test; one; two; end')
expect(cop.offenses).to be_empty
end
it 'accepts normal until' do
inspect_source(cop, 'until test; one; two; end')
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/multiple_compare_spec.rb 0000664 0000000 0000000 00000002071 13070542236 0026167 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::MultipleCompare do
let(:config) { RuboCop::Config.new }
subject(:cop) { described_class.new(config) }
shared_examples 'Check to use two comparison operator' do |op1, op2|
bad_source = "x #{op1} y #{op2} z"
good_source = "x #{op1} y && y #{op2} z"
it "registers an offense for #{bad_source}" do
inspect_source(cop, bad_source)
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use the `&&` operator to compare multiple values.'])
end
it 'autocorrects' do
new_source = autocorrect_source(cop, bad_source)
expect(new_source).to eq(good_source)
end
it "accepts for #{good_source}" do
inspect_source(cop, good_source)
expect(cop.offenses).to be_empty
end
end
%w[< > <= >=].repeated_permutation(2) do |op1, op2|
include_examples 'Check to use two comparison operator', op1, op2
end
it 'accepts to use one compare operator' do
inspect_source(cop, 'x < 1')
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/nested_method_definition_spec.rb 0000664 0000000 0000000 00000014375 13070542236 0027672 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::NestedMethodDefinition do
subject(:cop) { described_class.new }
it 'registers an offense for a nested method definition' do
inspect_source(cop, 'def x; def y; end; end')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for a nested singleton method definition' do
inspect_source(cop, ['class Foo',
'end',
'foo = Foo.new',
'def foo.bar',
' def baz',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for a nested method definition inside lambda' do
inspect_source(cop, ['def foo',
' bar = -> { def baz; puts; end }',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for a nested class method definition' do
inspect_source(cop, ['class Foo',
' def self.x',
' def self.y',
' end',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'does not register an offense for a lambda definition inside method' do
inspect_source(cop, ['def foo',
' bar = -> { puts }',
' bar.call',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register offense for nested definition inside instance_eval' do
inspect_source(cop, ['class Foo',
' def x(obj)',
' obj.instance_eval do',
' def y',
' end',
' end',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register offense for nested definition inside instance_exec' do
inspect_source(cop, ['class Foo',
' def x(obj)',
' obj.instance_exec do',
' def y',
' end',
' end',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register offense for definition of method on local var' do
inspect_source(cop, ['class Foo',
' def x(obj)',
' def obj.y',
' end',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register offense for nested definition inside class_eval' do
inspect_source(cop, ['class Foo',
' def x(klass)',
' klass.class_eval do',
' def y',
' end',
' end',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register offense for nested definition inside class_exec' do
inspect_source(cop, ['class Foo',
' def x(klass)',
' klass.class_exec do',
' def y',
' end',
' end',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register offense for nested definition inside module_eval' do
inspect_source(cop, ['class Foo',
' def self.define(mod)',
' mod.module_eval do',
' def y',
' end',
' end',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register offense for nested definition inside module_eval' do
inspect_source(cop, ['class Foo',
' def self.define(mod)',
' mod.module_exec do',
' def y',
' end',
' end',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register offense for nested definition inside class shovel' do
inspect_source(cop, ['class Foo',
' def bar',
' class << self',
' def baz',
' end',
' end',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register offense for nested definition inside Class.new' do
['(S)', ''].each do |constructor_args|
inspect_source(cop, ['class Foo',
' def self.define',
" Class.new#{constructor_args} do",
' def y',
' end',
' end',
' end',
'end'])
expect(cop.offenses).to be_empty
end
end
it 'does not register offense for nested definition inside Module.new' do
inspect_source(cop, ['class Foo',
' def self.define',
' Module.new do',
' def y',
' end',
' end',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register offense for nested definition inside Struct.new' do
['(:name)', ''].each do |constructor_args|
inspect_source(cop, ['class Foo',
' def self.define',
" Struct.new#{constructor_args} do",
' def y',
' end',
' end',
' end',
'end'])
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/next_without_accumulator_spec.rb 0000664 0000000 0000000 00000003377 13070542236 0030000 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::NextWithoutAccumulator do
subject(:cop) { described_class.new }
def code_without_accumulator(method_name)
<<-SOURCE
(1..4).#{method_name}(0) do |acc, i|
next if i.odd?
acc + i
end
SOURCE
end
def code_with_accumulator(method_name)
<<-SOURCE
(1..4).#{method_name}(0) do |acc, i|
next acc if i.odd?
acc + i
end
SOURCE
end
def code_with_nested_block(method_name)
<<-SOURCE
[(1..3), (4..6)].#{method_name}(0) do |acc, elems|
elems.each_with_index do |elem, i|
next if i == 1
acc << elem
end
acc
end
SOURCE
end
shared_examples 'reduce/inject' do |reduce_alias|
context "given a #{reduce_alias} block" do
it 'registers an offense for a bare next' do
inspect_source(cop, code_without_accumulator(reduce_alias))
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['next'])
end
it 'accepts next with a value' do
inspect_source(cop, code_with_accumulator(reduce_alias))
expect(cop.offenses).to be_empty
end
it 'accepts next within a nested block' do
inspect_source(cop, code_with_nested_block(reduce_alias))
expect(cop.offenses).to be_empty
end
end
end
it_behaves_like 'reduce/inject', :reduce
it_behaves_like 'reduce/inject', :inject
context 'given an unrelated block' do
it 'accepts a bare next' do
inspect_source(cop, code_without_accumulator(:foo))
expect(cop.offenses).to be_empty
end
it 'accepts next with a value' do
inspect_source(cop, code_with_accumulator(:foo))
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/non_local_exit_from_iterator_spec.rb 0000664 0000000 0000000 00000012652 13070542236 0030565 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::NonLocalExitFromIterator do
subject(:cop) { described_class.new }
context 'inspection' do
before do
inspect_source(cop, source)
end
let(:message) do
'Non-local exit from iterator, without return value. ' \
'`next`, `break`, `Array#find`, `Array#any?`, etc. is preferred.'
end
shared_examples_for 'offense detector' do
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(message)
expect(cop.offenses.first.severity.name).to eq(:warning)
expect(cop.highlights).to eq(['return'])
end
end
context 'when block is followed by method chain' do
context 'and has single argument' do
let(:source) { <<-END }
items.each do |item|
return if item.stock == 0
item.update!(foobar: true)
end
END
it_behaves_like('offense detector')
it { expect(cop.offenses.first.line).to eq(2) }
end
context 'and has multiple arguments' do
let(:source) { <<-END }
items.each_with_index do |item, i|
return if item.stock == 0
item.update!(foobar: true)
end
END
it_behaves_like('offense detector')
it { expect(cop.offenses.first.line).to eq(2) }
end
context 'and has no argument' do
let(:source) { <<-END }
item.with_lock do
return if item.stock == 0
item.update!(foobar: true)
end
END
it { expect(cop.offenses).to be_empty }
end
end
context 'when block is not followed by method chain' do
let(:source) { <<-END }
transaction do
return unless update_necessary?
find_each do |item|
return if item.stock == 0 # false-negative...
item.update!(foobar: true)
end
end
END
it { expect(cop.offenses).to be_empty }
end
context 'when block is lambda' do
let(:source) { <<-END }
items.each(lambda do |item|
return if item.stock == 0
item.update!(foobar: true)
end)
items.each -> (item) {
return if item.stock == 0
item.update!(foobar: true)
}
END
it { expect(cop.offenses).to be_empty }
end
context 'when lambda is inside of block followed by method chain' do
let(:source) { <<-END }
RSpec.configure do |config|
# some configuration
if Gem.loaded_specs["paper_trail"].version < Gem::Version.new("4.0.0")
current_behavior = ActiveSupport::Deprecation.behavior
ActiveSupport::Deprecation.behavior = lambda do |message, callstack|
return if message =~ /foobar/
Array.wrap(current_behavior).each do |behavior|
behavior.call(message, callstack)
end
end
# more configuration
end
end
END
it { expect(cop.offenses).to be_empty }
end
context 'when block in middle of nest is followed by method chain' do
let(:source) { <<-END }
transaction do
return unless update_necessary?
items.each do |item|
return if item.nil?
item.with_lock do
return if item.stock == 0
item.very_complicated_update_operation!
end
end
end
END
it 'registers offenses' do
expect(cop.offenses.size).to eq(2)
expect(cop.offenses[0].message).to eq(message)
expect(cop.offenses[0].severity.name).to eq(:warning)
expect(cop.offenses[0].line).to eq(4)
expect(cop.offenses[1].message).to eq(message)
expect(cop.offenses[1].severity.name).to eq(:warning)
expect(cop.offenses[1].line).to eq(6)
expect(cop.highlights).to eq(%w[return return])
end
end
context 'when return with value' do
let(:source) { <<-END }
def find_first_sold_out_item(items)
items.each do |item|
return item if item.stock == 0
item.foobar!
end
end
END
it { expect(cop.offenses).to be_empty }
end
context 'when the message is define_method' do
let(:source) { <<-END }
[:method_one, :method_two].each do |method_name|
define_method(method_name) do
return if predicate?
end
end
END
it { expect(cop.offenses).to be_empty }
end
context 'when the message is define_singleton_method' do
let(:source) { <<-END }
str = 'foo'
str.define_singleton_method :bar do |baz|
return unless baz
replace baz
end
END
it { expect(cop.offenses).to be_empty }
end
context 'when the return is within a nested method definition' do
context 'with an instance method definition' do
let(:source) { <<-END }
Foo.configure do |c|
def bar
return if baz?
end
end
END
it { expect(cop.offenses).to be_empty }
end
context 'with a class method definition' do
let(:source) { <<-END }
Foo.configure do |c|
def self.bar
return if baz?
end
end
END
it { expect(cop.offenses).to be_empty }
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/parentheses_as_grouped_expression_spec.rb 0000664 0000000 0000000 00000003404 13070542236 0031637 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::ParenthesesAsGroupedExpression do
subject(:cop) { described_class.new }
it 'registers an offense for method call with space before the ' \
'parenthesis' do
inspect_source(cop, 'a.func (x)')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for predicate method call with space ' \
'before the parenthesis' do
inspect_source(cop, 'is? (x)')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for math expression' do
inspect_source(cop, 'puts (2 + 3) * 4')
expect(cop.offenses.size).to eq(1)
end
it 'accepts a method call without arguments' do
inspect_source(cop, 'func')
expect(cop.offenses).to be_empty
end
it 'accepts a method call with arguments but no parentheses' do
inspect_source(cop, 'puts x')
expect(cop.offenses).to be_empty
end
it 'accepts a chain of method calls' do
inspect_source(cop, ['a.b',
'a.b 1',
'a.b(1)'])
expect(cop.offenses).to be_empty
end
it 'accepts method with parens as arg to method without' do
inspect_source(cop, 'a b(c)')
expect(cop.offenses).to be_empty
end
it 'accepts an operator call with argument in parentheses' do
inspect_source(cop, ['a % (b + c)',
'a.b = (c == d)'])
expect(cop.offenses).to be_empty
end
it 'accepts a space inside opening paren followed by left paren' do
inspect_source(cop, 'a( (b) )')
expect(cop.offenses).to be_empty
end
it "doesn't register an offense for a call with multiple arguments" do
# there is no ambiguity here
inspect_source(cop, 'assert_equal (0..1.9), acceleration.domain')
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/percent_string_array_spec.rb 0000664 0000000 0000000 00000004206 13070542236 0027054 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::PercentStringArray do
subject(:cop) { described_class.new }
def expect_offense(source)
inspect_source(cop, source)
expect(cop.offenses.map(&:message)).to eq([described_class::MSG])
expect(cop.highlights).to eq([source])
end
context 'detecting quotes or commas in a %w/%W string' do
%w[w W].each do |char|
it 'accepts tokens without quotes or commas' do
inspect_source(cop, "%#{char}(foo bar baz)")
expect(cop.offenses).to be_empty
end
[
%(%#{char}(' ")),
%(%#{char}(' " ! = # ,)),
':"#{a}"',
%(%#{char}(\#{a} b))
].each do |false_positive|
it "accepts likely false positive #{false_positive}" do
inspect_source(cop, false_positive)
expect(cop.offenses).to be_empty
end
end
it 'adds an offense if tokens contain quotes and are comma separated' do
expect_offense("%#{char}('foo', 'bar', 'baz')")
end
it 'adds an offense if tokens contain both types of quotes' do
expect_offense(%{%#{char}('foo' "bar" 'baz')})
end
it 'adds an offense if one token is quoted but there are no commas' do
expect_offense("%#{char}('foo' bar baz)")
end
it 'adds an offense if there are no quotes but one comma' do
expect_offense("%#{char}(foo, bar baz)")
end
end
end
context 'autocorrection' do
let(:source) do
<<-SOURCE
%w('a', "b", c', "d, e f)
%W('a', "b", c', "d, e f)
SOURCE
end
let(:expected_corrected_source) do
<<-CORRECTED_SOURCE
%w(a b c d e f)
%W(a b c d e f)
CORRECTED_SOURCE
end
it 'removes undesireable characters' do
expect(autocorrect_source(cop, source)).to eq(expected_corrected_source)
end
end
context 'with invalid byte sequence in UTF-8' do
it 'add an offences if tokens contain quotes' do
expect_offense('%W("a\255\255")')
end
it 'accepts if tokens contain invalid byte sequence only' do
inspect_source(cop, '%W(\255)')
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/percent_symbol_array_spec.rb 0000664 0000000 0000000 00000003012 13070542236 0027045 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::PercentSymbolArray do
subject(:cop) { described_class.new }
def expect_offense(source)
inspect_source(cop, source)
expect(cop.offenses.map(&:message)).to eq([described_class::MSG])
expect(cop.highlights).to eq([source])
end
context 'detecting colons or commas in a %i/%I string' do
%w[i I].each do |char|
it 'accepts tokens without colons or commas' do
inspect_source(cop, "%#{char}(foo bar baz)")
expect(cop.offenses).to be_empty
end
it 'accepts likely false positive $,' do
inspect_source(cop, "%#{char}{$,}")
expect(cop.offenses).to be_empty
end
it 'adds an offense if symbols contain colons and are comma separated' do
expect_offense("%#{char}(:foo, :bar, :baz)")
end
it 'adds an offense if one symbol has a colon but there are no commas' do
expect_offense("%#{char}(:foo bar baz)")
end
it 'adds an offense if there are no colons but one comma' do
expect_offense("%#{char}(foo, bar baz)")
end
end
end
context 'autocorrection' do
let(:source) do
<<-SOURCE
%i(:a, :b, c, d e :f)
%I(:a, :b, c, d e :f)
SOURCE
end
let(:expected_corrected_source) do
<<-CORRECTED_SOURCE
%i(a b c d e f)
%I(a b c d e f)
CORRECTED_SOURCE
end
it 'removes undesireable characters' do
expect(autocorrect_source(cop, source)).to eq(expected_corrected_source)
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/rand_one_spec.rb 0000664 0000000 0000000 00000002531 13070542236 0024414 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::RandOne do
subject(:cop) { described_class.new }
before { inspect_source(cop, source) }
shared_examples 'offenses' do |source|
describe source do
let(:source) { source }
it 'registers an offense' do
expect(cop.messages).to eq(
[
"`#{source}` always returns `0`. " \
'Perhaps you meant `rand(2)` or `rand`?'
]
)
expect(cop.highlights).to eq([source])
end
end
end
shared_examples 'no offense' do |source|
describe source do
let(:source) { source }
it "doesn't register an offense" do
expect(cop.messages).to be_empty
end
end
end
it_behaves_like 'offenses', 'rand 1'
it_behaves_like 'offenses', 'rand(-1)'
it_behaves_like 'offenses', 'rand(1.0)'
it_behaves_like 'offenses', 'rand(-1.0)'
it_behaves_like 'no offense', 'rand'
it_behaves_like 'no offense', 'rand(2)'
it_behaves_like 'no offense', 'rand(-1..1)'
it_behaves_like 'offenses', 'Kernel.rand(1)'
it_behaves_like 'offenses', 'Kernel.rand(-1)'
it_behaves_like 'offenses', 'Kernel.rand 1.0'
it_behaves_like 'offenses', 'Kernel.rand(-1.0)'
it_behaves_like 'no offense', 'Kernel.rand'
it_behaves_like 'no offense', 'Kernel.rand 2'
it_behaves_like 'no offense', 'Kernel.rand(-1..1)'
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/require_parentheses_spec.rb 0000664 0000000 0000000 00000005335 13070542236 0026711 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::RequireParentheses do
subject(:cop) { described_class.new }
it 'registers an offense for missing parentheses around expression with ' \
'&& operator' do
inspect_source(cop, ["if day.is? 'monday' && month == :jan",
' foo',
'end'])
expect(cop.highlights).to eq(["day.is? 'monday' && month == :jan"])
expect(cop.messages)
.to eq(['Use parentheses in the method call to avoid confusion about ' \
'precedence.'])
end
it 'registers an offense for missing parentheses around expression with ' \
'|| operator' do
inspect_source(cop, "day_is? 'tuesday' || true")
expect(cop.highlights).to eq(["day_is? 'tuesday' || true"])
end
it 'registers an offense for missing parentheses around expression in ' \
'ternary' do
inspect_source(cop, "wd.include? 'tuesday' && true == true ? a : b")
expect(cop.highlights).to eq(["wd.include? 'tuesday' && true == true"])
end
it 'accepts missing parentheses around expression with + operator' do
inspect_source(cop, ["if day_is? 'tuesday' + rest",
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts method calls without parentheses followed by keyword and/or' do
inspect_source(cop, ["if day.is? 'tuesday' and month == :jan",
'end',
"if day.is? 'tuesday' or month == :jan",
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts method calls that are all operations' do
inspect_source(cop, ['if current_level == max + 1',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts condition that is not a call' do
inspect_source(cop, ['if @debug',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts parentheses around expression with boolean operator' do
inspect_source(cop, ["if day.is?('tuesday' && true == true)",
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts method call with parentheses in ternary' do
inspect_source(cop, "wd.include?('tuesday' && true == true) ? a : b")
expect(cop.offenses).to be_empty
end
it 'accepts missing parentheses when method is not a predicate' do
inspect_source(cop, "weekdays.foo 'tuesday' && true == true")
expect(cop.offenses).to be_empty
end
it 'accepts calls to methods that are setters' do
inspect_source(cop, 's.version = @version || ">= 1.8.5"')
expect(cop.offenses).to be_empty
end
it 'accepts calls to methods that are operators' do
inspect_source(cop, 'a[b || c]')
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/rescue_exception_spec.rb 0000664 0000000 0000000 00000007212 13070542236 0026174 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::RescueException do
subject(:cop) { described_class.new }
it 'registers an offense for rescue from Exception' do
inspect_source(cop,
['begin',
' something',
'rescue Exception',
' #do nothing',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for rescue with ::Exception' do
inspect_source(cop,
['begin',
' something',
'rescue ::Exception',
' #do nothing',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for rescue with StandardError, Exception' do
inspect_source(cop,
['begin',
' something',
'rescue StandardError, Exception',
' #do nothing',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for rescue with Exception => e' do
inspect_source(cop,
['begin',
' something',
'rescue Exception => e',
' #do nothing',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'does not register an offense for rescue with no class' do
inspect_source(cop,
['begin',
' something',
' return',
'rescue',
' file.close',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense for rescue with no class and => e' do
inspect_source(cop,
['begin',
' something',
' return',
'rescue => e',
' file.close',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense for rescue with other class' do
inspect_source(cop,
['begin',
' something',
' return',
'rescue ArgumentError => e',
' file.close',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense for rescue with other classes' do
inspect_source(cop,
['begin',
' something',
' return',
'rescue EOFError, ArgumentError => e',
' file.close',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense for rescue with a module prefix' do
inspect_source(cop,
['begin',
' something',
' return',
'rescue Test::Exception => e',
' file.close',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not crash when the splat operator is used in a rescue' do
inspect_source(cop,
['ERRORS = [Exception]',
'begin',
' a = 3 / 0',
'rescue *ERRORS',
' puts e',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not crash when the namespace of a rescued class is in a local ' \
'variable' do
inspect_source(cop,
['adapter = current_adapter',
'begin',
'rescue adapter::ParseError',
'end'])
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/safe_navigation_chain_spec.rb 0000664 0000000 0000000 00000010410 13070542236 0027121 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::SafeNavigationChain, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) do
{ 'Whitelist' => %w[present? blank? try presence] }
end
shared_examples :accepts do |name, code|
it "accepts usages of #{name}" do
inspect_source(cop, code)
expect(cop.offenses).to be_empty
end
end
shared_examples :offense do |name, code|
it "registers an offense for #{name}" do
inspect_source(cop, code)
expect(cop.messages)
.to eq(
['Do not chain ordinary method call after safe navigation operator.']
)
end
end
shared_examples :autocorrect do |name, source, correction|
it "corrects #{name}" do
new_source = autocorrect_source_with_loop(cop, source)
expect(new_source).to eq(correction)
end
end
context 'TargetRubyVersion >= 2.3', :ruby23 do
[
['ordinary method chain', 'x.foo.bar.baz'],
['ordinary method chain with argument', 'x.foo(x).bar(y).baz(z)'],
['method chain with safe navigation only', 'x&.foo&.bar&.baz'],
['method chain with safe navigation only with argument',
'x&.foo(x)&.bar(y)&.baz(z)'],
['safe navigation at last only', 'x.foo.bar&.baz'],
['safe navigation at last only with argument', 'x.foo(x).bar(y)&.baz(z)'],
['safe navigation with == operator', 'x&.foo == bar'],
['safe navigation with === operator', 'x&.foo === bar'],
['safe navigation with || operator', 'x&.foo || bar'],
['safe navigation with && operator', 'x&.foo && bar'],
['safe navigation with | operator', 'x&.foo | bar'],
['safe navigation with & operator', 'x&.foo & bar'],
['safe navigation with `nil?` method', 'x&.foo.nil?'],
['safe navigation with `present?` method', 'x&.foo.present?'],
['safe navigation with `blank?` method', 'x&.foo.blank?'],
['safe navigation with `try` method', 'a&.b.try(:c)'],
['safe navigation with assignment method', 'x&.foo = bar'],
['safe navigation with self assignment method', 'x&.foo += bar']
].each do |name, code|
include_examples :accepts, name, code
end
[
['ordinary method call exists after safe navigation method call',
'x&.foo.bar'],
['ordinary method call exists after safe navigation method call' \
'with argument',
'x&.foo(x).bar(y)'],
['ordinary method chain exists after safe navigation method call',
'x&.foo.bar.baz'],
['ordinary method chain exists after safe navigation method call' \
'with argument',
'x&.foo(x).bar(y).baz(z)'],
['safe navigation with < operator', 'x&.foo < bar'],
['safe navigation with > operator', 'x&.foo > bar'],
['safe navigation with <= operator', 'x&.foo <= bar'],
['safe navigation with >= operator', 'x&.foo >= bar'],
['safe navigation with + operator', 'x&.foo + bar'],
['safe navigation with []', 'x&.foo[bar]'],
['safe navigation with []=', 'x&.foo[bar] = baz']
].each do |name, code|
include_examples :offense, name, code
end
[
['ordinary method call exists after safe navigation method call',
'x&.foo.bar', 'x&.foo&.bar'],
['ordinary method call exists after safe navigation method call' \
'with argument',
'x&.foo(x).bar(y)', 'x&.foo(x)&.bar(y)'],
['ordinary method chain exists after safe navigation method call',
'x&.foo.bar.baz', 'x&.foo&.bar&.baz'],
['ordinary method chain exists after safe navigation method call' \
'with argument',
'x&.foo(x).bar(y).baz(z)', 'x&.foo(x)&.bar(y)&.baz(z)'],
# Do not autocorrect the followings
['safe navigation with < operator', 'x&.foo < bar', 'x&.foo < bar'],
['safe navigation with > operator', 'x&.foo > bar', 'x&.foo > bar'],
['safe navigation with <= operator', 'x&.foo <= bar', 'x&.foo <= bar'],
['safe navigation with >= operator', 'x&.foo >= bar', 'x&.foo >= bar'],
['safe navigation with + operator', 'x&.foo + bar', 'x&.foo + bar'],
['safe navigation with []', 'x&.foo[bar]', 'x&.foo[bar]'],
['safe navigation with []=', 'x&.foo[bar] = baz', 'x&.foo[bar] = baz']
].each do |name, code, correction|
include_examples :autocorrect, name, code, correction
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/shadowed_exception_spec.rb 0000664 0000000 0000000 00000043266 13070542236 0026515 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::ShadowedException do
subject(:cop) { described_class.new }
context 'modifier rescue' do
it 'accepts rescue in its modifier form' do
inspect_source(cop, 'foo rescue nil')
expect(cop.offenses).to be_empty
end
end
context 'single rescue' do
it 'accepts an empty rescue' do
inspect_source(cop, ['begin',
' something',
'rescue',
' handle_exception',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts rescuing a single exception' do
inspect_source(cop, ['begin',
' something',
'rescue Exception',
' handle_exception',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts rescuing a single custom exception' do
inspect_source(cop, ['begin',
' something',
'rescue NonStandardException',
' handle_exception',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts rescuing a custom exception and a standard exception' do
inspect_source(cop, ['begin',
' something',
'rescue Error, NonStandardException',
' handle_exception',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts rescuing multiple custom exceptions' do
inspect_source(cop, ['begin',
' something',
'rescue CustomError, NonStandardException',
' handle_exception',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense rescuing exceptions that are ' \
'ancestors of each other ' do
inspect_source(cop, ['def',
' something',
'rescue StandardError, RuntimeError',
' handle_exception',
'end'])
expect(cop.messages).to eq(['Do not shadow rescued Exceptions.'])
end
it 'registers an offense rescuing Exception with any other error or ' \
'exception' do
inspect_source(cop, ['begin',
' something',
'rescue NonStandardError, Exception',
' handle_exception',
'end'])
expect(cop.messages).to eq(['Do not shadow rescued Exceptions.'])
end
it 'accepts rescuing a single exception that is assigned to a variable' do
inspect_source(cop, ['begin',
' something',
'rescue Exception => e',
' handle_exception(e)',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts rescuing a single exception that has an ensure' do
inspect_source(cop, ['begin',
' something',
'rescue Exception',
' handle_exception',
'ensure',
' everything_is_ok',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts rescuing a single exception that has an else' do
inspect_source(cop, ['begin',
' something',
'rescue Exception',
' handle_exception',
'else',
' handle_non_exception',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts rescuing a multiple exceptions that are not ancestors that ' \
'have an else' do
inspect_source(cop, ['begin',
' something',
'rescue NoMethodError, ZeroDivisionError',
' handle_exception',
'else',
' handle_non_exception',
'end'])
expect(cop.offenses).to be_empty
end
context 'when there are multiple levels of exceptions in the same rescue' do
it 'registers an offense for two exceptions' do
inspect_source(cop, ['begin',
' something',
'rescue StandardError, NameError',
' foo',
'end'])
expect(cop.messages).to eq(['Do not shadow rescued Exceptions.'])
expect(cop.highlights).to eq(['rescue StandardError, NameError'])
end
it 'registers an offense for more than two exceptions' do
inspect_source(cop, ['begin',
' something',
'rescue StandardError, NameError, NoMethodError',
' foo',
'end'])
expect(cop.messages).to eq(['Do not shadow rescued Exceptions.'])
expect(cop.highlights)
.to eq(['rescue StandardError, NameError, NoMethodError'])
end
end
it 'registers an offense for the same exception multiple times' do
inspect_source(cop, ['begin',
' something',
'rescue NameError, NameError',
' foo',
'end'])
expect(cop.messages).to eq(['Do not shadow rescued Exceptions.'])
expect(cop.highlights)
.to eq(['rescue NameError, NameError'])
end
it 'accepts splat arguments passed to rescue' do
inspect_source(cop, ['begin',
' a',
'rescue *FOO',
' b',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts rescuing nil' do
inspect_source(cop, ['begin',
' a',
'rescue nil',
' b',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts rescuing nil and another exception' do
inspect_source(cop, ['begin',
' a',
'rescue nil, Exception',
' b',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense when rescuing nil multiple exceptions of ' \
'different levels' do
inspect_source(cop, ['begin',
' a',
'rescue nil, StandardError, Exception',
' b',
'end'])
expect(cop.messages).to eq(['Do not shadow rescued Exceptions.'])
expect(cop.highlights).to eq(['rescue nil, StandardError, Exception'])
end
end
context 'multiple rescues' do
it 'registers an offense when a higher level exception is rescued before' \
' a lower level exception' do
inspect_source(cop, ['begin',
' something',
'rescue Exception',
' handle_exception',
'rescue StandardError',
' handle_standard_error',
'end'])
expect(cop.messages).to eq(['Do not shadow rescued Exceptions.'])
expect(cop.highlights).to eq([['rescue Exception',
' handle_exception',
'rescue StandardError'].join("\n")])
end
it 'registers an offense when a higher level exception is rescued before ' \
'a lower level exception when there are multiple exceptions ' \
'rescued in a group' do
inspect_source(cop, ['begin',
' something',
'rescue Exception',
' handle_exception',
'rescue NoMethodError, ZeroDivisionError',
' handle_standard_error',
'end'])
expect(cop.messages).to eq(['Do not shadow rescued Exceptions.'])
expect(cop.highlights).to eq([['rescue Exception',
' handle_exception',
'rescue NoMethodError, ZeroDivisionError']
.join("\n")])
end
it 'registers an offense rescuing out of order exceptions when there ' \
'is an ensure' do
inspect_source(cop, ['begin',
' something',
'rescue Exception',
' handle_exception',
'rescue StandardError',
' handle_standard_error',
'ensure',
' everything_is_ok',
'end'])
expect(cop.messages).to eq(['Do not shadow rescued Exceptions.'])
expect(cop.highlights).to eq([['rescue Exception',
' handle_exception',
'rescue StandardError'].join("\n")])
end
it 'accepts rescuing exceptions in order of level' do
inspect_source(cop, ['begin',
' something',
'rescue StandardError',
' handle_standard_error',
'rescue Exception',
' handle_exception',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts many (>= 7) rescue groups' do
inspect_source(cop, ['begin',
' something',
'rescue StandardError',
' handle_error',
'rescue ErrorA',
' handle_error',
'rescue ErrorB',
' handle_error',
'rescue ErrorC',
' handle_error',
'rescue ErrorD',
' handle_error',
'rescue ErrorE',
' handle_error',
'rescue ErrorF',
' handle_error',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts rescuing exceptions in order of level with multiple ' \
'exceptions in a group' do
inspect_source(cop, ['begin',
' something',
'rescue NoMethodError, ZeroDivisionError',
' handle_standard_error',
'rescue Exception',
' handle_exception',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts rescuing exceptions in order of level with multiple ' \
'exceptions in a group with custom exceptions' do
inspect_source(cop, ['begin',
' something',
'rescue NonStandardError, NoMethodError',
' handle_standard_error',
'rescue Exception',
' handle_exception',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts rescuing custom exceptions in multiple rescue groups' do
inspect_source(cop, ['begin',
' something',
'rescue NonStandardError, OtherError',
' handle_standard_error',
'rescue CustomError',
' handle_exception',
'end'])
expect(cop.offenses).to be_empty
end
context 'splat arguments' do
it 'accepts splat arguments passed to multiple rescues' do
inspect_source(cop, ['begin',
' a',
'rescue *FOO',
' b',
'rescue *BAR',
' c',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for splat arguments rescued after ' \
'rescuing a known exception' do
inspect_source(cop, ['begin',
' a',
'rescue StandardError',
' b',
'rescue *BAR',
' c',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for splat arguments rescued after ' \
'rescuing Exception' do
inspect_source(cop, ['begin',
' a',
'rescue Exception',
' b',
'rescue *BAR',
' c',
'end'])
expect(cop.messages).to eq(['Do not shadow rescued Exceptions.'])
expect(cop.highlights).to eq([['rescue Exception',
' b',
'rescue *BAR'].join("\n")])
end
end
context 'exceptions from different ancestry chains' do
it 'accepts rescuing exceptions in one order' do
inspect_source(cop, ['begin',
' a',
'rescue ArgumentError',
' b',
'rescue Interrupt',
' c',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts rescuing exceptions in another order' do
inspect_source(cop, ['begin',
' a',
'rescue Interrupt',
' b',
'rescue ArgumentError',
' c',
'end'])
expect(cop.offenses).to be_empty
end
end
it 'accepts rescuing nil before another exception' do
inspect_source(cop, ['begin',
' a',
'rescue nil',
' b',
'rescue',
' c',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts rescuing nil after another exception' do
inspect_source(cop, ['begin',
' a',
'rescue',
' b',
'rescue nil',
' c',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts rescuing a known exception after an unknown exceptions' do
inspect_source(cop, ['begin',
' a',
'rescue UnknownException',
' b',
'rescue StandardError',
' c',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts rescuing a known exception before an unknown exceptions' do
inspect_source(cop, ['begin',
' a',
'rescue StandardError',
' b',
'rescue UnknownException',
' c',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts rescuing a known exception between unknown exceptions' do
inspect_source(cop, ['begin',
' a',
'rescue UnknownException',
' b',
'rescue StandardError',
' c',
'rescue AnotherUnknownException',
' d',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense rescuing Exception before an unknown exceptions' do
inspect_source(cop, ['begin',
' a',
'rescue Exception',
' b',
'rescue UnknownException',
' c',
'end'])
expect(cop.messages).to eq(['Do not shadow rescued Exceptions.'])
expect(cop.highlights).to eq([['rescue Exception',
' b',
'rescue UnknownException'].join("\n")])
end
it 'ignores expressions of non-const' do
inspect_source(cop, ['begin',
' a',
'rescue foo',
' b',
'rescue [bar]',
' c',
'end'])
expect(cop.offenses).to be_empty
end
context 'last rescue does not specify exception class' do
let(:source) do
['begin',
'rescue A, B',
' do_something',
'rescue C',
' do_something',
'rescue',
' do_something',
'end']
end
it 'does not raise error' do
expect { inspect_source(cop, source) }.not_to raise_error
end
it 'highlights range ending at rescue keyword' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/shadowing_outer_local_variable_spec.rb 0000664 0000000 0000000 00000012244 13070542236 0031051 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::ShadowingOuterLocalVariable do
subject(:cop) { described_class.new }
context 'when a block argument has same name ' \
'as an outer scope variable' do
let(:source) do
[
'def some_method',
' foo = 1',
' puts foo',
' 1.times do |foo|',
' end',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Shadowing outer local variable - `foo`.')
expect(cop.offenses.first.line).to eq(4)
end
include_examples 'mimics MRI 2.1'
end
context 'when a splat block argument has same name ' \
'as an outer scope variable' do
let(:source) do
[
'def some_method',
' foo = 1',
' puts foo',
' 1.times do |*foo|',
' end',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Shadowing outer local variable - `foo`.')
expect(cop.offenses.first.line).to eq(4)
end
include_examples 'mimics MRI 2.1'
end
context 'when a block block argument has same name ' \
'as an outer scope variable' do
let(:source) do
[
'def some_method',
' foo = 1',
' puts foo',
' proc_taking_block = proc do |&foo|',
' end',
' proc_taking_block.call do',
' end',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Shadowing outer local variable - `foo`.')
expect(cop.offenses.first.line).to eq(4)
end
include_examples 'mimics MRI 2.1'
end
context 'when a block local variable has same name ' \
'as an outer scope variable' do
let(:source) do
[
'def some_method',
' foo = 1',
' puts foo',
' 1.times do |i; foo|',
' puts foo',
' end',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Shadowing outer local variable - `foo`.')
expect(cop.offenses.first.line).to eq(4)
end
include_examples 'mimics MRI 2.1', 'shadowing'
end
context 'when a block argument has different name ' \
'with outer scope variables' do
let(:source) do
[
'def some_method',
' foo = 1',
' puts foo',
' 1.times do |bar|',
' end',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when an outer scope variable is reassigned in a block' do
let(:source) do
[
'def some_method',
' foo = 1',
' puts foo',
' 1.times do',
' foo = 2',
' end',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when an outer scope variable is referenced in a block' do
let(:source) do
[
'def some_method',
' foo = 1',
' puts foo',
' 1.times do',
' puts foo',
' end',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when multiple block arguments have same name "_"' do
let(:source) do
[
'def some_method',
' 1.times do |_, foo, _|',
' end',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when multiple block arguments have ' \
'a same name starts with "_"' do
let(:source) do
[
'def some_method',
' 1.times do |_foo, bar, _foo|',
' end',
'end'
]
end
include_examples 'accepts' unless RUBY_VERSION < '2.0'
include_examples 'mimics MRI 2.1'
end
context 'when a block argument has same name "_" ' \
'as outer scope variable "_"' do
let(:source) do
[
'def some_method',
' _ = 1',
' puts _',
' 1.times do |_|',
' end',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a block argument has a same name starts with "_" ' \
'as an outer scope variable' do
let(:source) do
[
'def some_method',
' _foo = 1',
' puts _foo',
' 1.times do |_foo|',
' end',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a method argument has same name ' \
'as an outer scope variable' do
let(:source) do
[
'class SomeClass',
' foo = 1',
' puts foo',
' def some_method(foo)',
' end',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/string_conversion_in_interpolation_spec.rb 0000664 0000000 0000000 00000003077 13070542236 0032045 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::StringConversionInInterpolation do
subject(:cop) { described_class.new }
it 'registers an offense for #to_s in interpolation' do
inspect_source(cop, '"this is the #{result.to_s}"')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Redundant use of `Object#to_s` in interpolation.'])
end
it 'detects #to_s in an interpolation with several expressions' do
inspect_source(cop, '"this is the #{top; result.to_s}"')
expect(cop.offenses.size).to eq(1)
end
it 'accepts #to_s with arguments in an interpolation' do
inspect_source(cop, '"this is a #{result.to_s(8)}"')
expect(cop.offenses).to be_empty
end
it 'accepts interpolation without #to_s' do
inspect_source(cop, '"this is the #{result}"')
expect(cop.offenses).to be_empty
end
it 'does not explode on implicit receiver' do
inspect_source(cop, '"#{to_s}"')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `self` instead of `Object#to_s` in interpolation.'])
end
it 'does not explode on empty interpolation' do
inspect_source(cop, '"this is #{} silly"')
expect(cop.offenses).to be_empty
end
it 'autocorrects by removing the redundant to_s' do
corrected = autocorrect_source(cop, ['"some #{something.to_s}"'])
expect(corrected).to eq '"some #{something}"'
end
it 'autocorrects implicit receiver by replacing to_s with self' do
corrected = autocorrect_source(cop, ['"some #{to_s}"'])
expect(corrected).to eq '"some #{self}"'
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/syntax_spec.rb 0000664 0000000 0000000 00000002155 13070542236 0024157 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::Syntax do
describe '.offense_from_diagnostic' do
subject(:offense) do
described_class.offense_from_diagnostic(diagnostic, 2.0)
end
let(:diagnostic) { Parser::Diagnostic.new(level, reason, args, location) }
let(:level) { :warning }
let(:reason) { :odd_hash }
let(:args) { [] }
let(:location) { double('location').as_null_object }
it 'returns an offense' do
expect(offense).to be_a(RuboCop::Cop::Offense)
end
it "sets diagnostic's level to offense's severity" do
expect(offense.severity).to eq(level)
end
it "sets diagnostic's message to offense's message" do
expect(offense.message).to eq(
['odd number of entries for a hash',
'(Using Ruby 2.0 parser; configure using `TargetRubyVersion` ' \
'parameter, under `AllCops`)'].join("\n")
)
end
it "sets diagnostic's location to offense's location" do
expect(offense.location).to eq(location)
end
it 'sets Syntax as a cop name' do
expect(offense.cop_name).to eq('Syntax')
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/underscore_prefixed_variable_name_spec.rb 0000664 0000000 0000000 00000010370 13070542236 0031533 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::UnderscorePrefixedVariableName do
subject(:cop) { described_class.new }
before do
inspect_source(cop, source)
end
context 'when an underscore-prefixed variable is used' do
let(:source) { <<-END }
def some_method
_foo = 1
puts _foo
end
END
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Do not use prefix `_` for a variable that is used.')
expect(cop.offenses.first.severity.name).to eq(:warning)
expect(cop.offenses.first.line).to eq(2)
expect(cop.highlights).to eq(['_foo'])
end
end
context 'when non-underscore-prefixed variable is used' do
let(:source) { <<-END }
def some_method
foo = 1
puts foo
end
END
it 'accepts' do
expect(cop.offenses).to be_empty
end
end
context 'when an underscore-prefixed variable is reassigned' do
let(:source) { <<-END }
def some_method
_foo = 1
_foo = 2
end
END
it 'accepts' do
expect(cop.offenses).to be_empty
end
end
context 'when an underscore-prefixed method argument is used' do
let(:source) { <<-END }
def some_method(_foo)
puts _foo
end
END
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['_foo'])
end
end
context 'when an underscore-prefixed block argument is used' do
let(:source) { <<-END }
1.times do |_foo|
puts _foo
end
END
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['_foo'])
end
end
context 'when an underscore-prefixed variable in top-level scope is used' do
let(:source) { <<-END }
_foo = 1
puts _foo
END
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['_foo'])
end
end
context 'when an underscore-prefixed variable is captured by a block' do
let(:source) { <<-END }
_foo = 1
1.times do
_foo = 2
end
END
it 'accepts' do
expect(cop.offenses).to be_empty
end
end
context 'when an underscore-prefixed named capture variable is used' do
let(:source) { <<-END }
/(?<_foo>\\w+)/ =~ 'FOO'
puts _foo
END
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['/(?<_foo>\\w+)/'])
end
end
%w[super binding].each do |keyword|
context "in a method calling `#{keyword}` without arguments" do
context 'when an underscore-prefixed argument is not used explicitly' do
let(:source) { <<-END }
def some_method(*_)
#{keyword}
end
END
it 'accepts' do
expect(cop.offenses).to be_empty
end
end
context 'when an underscore-prefixed argument is used explicitly' do
let(:source) { <<-END }
def some_method(*_)
#{keyword}
puts _
end
END
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['_'])
end
end
end
context "in a method calling `#{keyword}` with arguments" do
context 'when an underscore-prefixed argument is not used' do
let(:source) { <<-END }
def some_method(*_)
#{keyword}(:something)
end
END
it 'accepts' do
expect(cop.offenses).to be_empty
end
end
context 'when an underscore-prefixed argument is used explicitly' do
let(:source) { <<-END }
def some_method(*_)
#{keyword}(*_)
end
END
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['_'])
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/unified_integer_spec.rb 0000664 0000000 0000000 00000003564 13070542236 0025776 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::UnifiedInteger do
let(:config) { RuboCop::Config.new }
subject(:cop) { described_class.new(config) }
shared_examples 'registers an offence' do |klass|
context "when #{klass}" do
context 'without any decorations' do
let(:source) { "1.is_a?(#{klass})" }
it 'registers an offence' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(["Use `Integer` instead of `#{klass}`."])
end
it 'autocorrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('1.is_a?(Integer)')
end
end
context 'when explicitly specified as toplevel constant' do
let(:source) { "1.is_a?(::#{klass})" }
it 'registers an offence' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(["Use `Integer` instead of `#{klass}`."])
end
it 'autocorrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('1.is_a?(::Integer)')
end
end
context 'with MyNamespace' do
let(:source) { "1.is_a?(MyNamespace::#{klass})" }
include_examples 'accepts'
end
end
end
include_examples 'registers an offence', 'Fixnum'
include_examples 'registers an offence', 'Bignum'
context 'when Integer' do
context 'without any decorations' do
let(:source) { '1.is_a?(Integer)' }
include_examples 'accepts'
end
context 'when explicitly specified as toplevel constant' do
let(:source) { '1.is_a?(::Integer)' }
include_examples 'accepts'
end
context 'with MyNamespace' do
let(:source) { '1.is_a?(MyNamespace::Integer)' }
include_examples 'accepts'
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/unneeded_disable_spec.rb 0000664 0000000 0000000 00000033216 13070542236 0026105 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::UnneededDisable do
describe '.check' do
let(:cop) do
cop = described_class.new
cop.instance_eval { @options[:auto_correct] = true }
cop.processed_source = processed_source
cop
end
let(:processed_source) do
RuboCop::ProcessedSource.new(source, ruby_version)
end
let(:comments) { processed_source.comments }
let(:corrected_source) do
RuboCop::Cop::Corrector
.new(processed_source.buffer, cop.corrections)
.rewrite
end
before do
cop.check(offenses, cop_disabled_line_ranges, comments)
end
context 'when there are no disabled lines' do
let(:offenses) { [] }
let(:cop_disabled_line_ranges) { {} }
let(:source) { '' }
it 'returns an empty array' do
expect(cop.offenses).to eq([])
end
end
context 'when there are disabled lines' do
context 'and there are no offenses' do
let(:offenses) { [] }
context 'and a comment disables' do
context 'one cop' do
let(:source) { "# rubocop:disable Metrics/MethodLength\n" }
let(:cop_disabled_line_ranges) do
{ 'Metrics/MethodLength' => [1..Float::INFINITY] }
end
it 'returns an offense' do
expect(cop.messages)
.to eq(['Unnecessary disabling of `Metrics/MethodLength`.'])
expect(cop.highlights)
.to eq(['# rubocop:disable Metrics/MethodLength'])
end
it 'gives the right cop name' do
expect(cop.name).to eq('Lint/UnneededDisable')
end
it 'autocorrects' do
expect(corrected_source).to eq('')
end
end
context 'an unknown cop' do
let(:source) { '# rubocop:disable UnknownCop' }
let(:cop_disabled_line_ranges) do
{ 'UnknownCop' => [1..Float::INFINITY] }
end
it 'returns an offense' do
expect(cop.messages)
.to eq(['Unnecessary disabling of `UnknownCop` (unknown cop).'])
expect(cop.highlights)
.to eq(['# rubocop:disable UnknownCop'])
end
end
context 'itself' do
let(:source) { '# rubocop:disable Lint/UnneededDisable' }
let(:cop_disabled_line_ranges) do
{ 'Lint/UnneededDisable' => [1..Float::INFINITY] }
end
it 'does not return an offense' do
expect(cop.offenses).to be_empty
end
end
context 'itself and another cop' do
context 'disabled on the same range' do
let(:source) do
'# rubocop:disable Lint/UnneededDisable, Metrics/ClassLength'
end
let(:cop_disabled_line_ranges) do
{ 'Lint/UnneededDisable' => [1..Float::INFINITY],
'Metrics/ClassLength' => [1..Float::INFINITY] }
end
it 'does not return an offense' do
expect(cop.offenses).to be_empty
end
end
end
context 'multiple cops' do
let(:source) do
'# rubocop:disable Metrics/MethodLength, Metrics/ClassLength'
end
let(:cop_disabled_line_ranges) do
{ 'Metrics/ClassLength' => [1..Float::INFINITY],
'Metrics/MethodLength' => [1..Float::INFINITY] }
end
it 'returns an offense' do
expect(cop.messages)
.to eq(['Unnecessary disabling of `Metrics/ClassLength`, ' \
'`Metrics/MethodLength`.'])
end
end
context 'multiple cops, and one of them has offenses' do
let(:source) do
'# rubocop:disable Metrics/MethodLength, Metrics/ClassLength, ' \
'Lint/Debugger, Lint/AmbiguousOperator'
end
let(:cop_disabled_line_ranges) do
{ 'Metrics/ClassLength' => [1..Float::INFINITY],
'Metrics/MethodLength' => [1..Float::INFINITY],
'Lint/Debugger' => [1..Float::INFINITY],
'Lint/AmbiguousOperator' => [1..Float::INFINITY] }
end
let(:offenses) do
[
RuboCop::Cop::Offense.new(:convention,
OpenStruct.new(line: 7, column: 0),
'Class has too many lines.',
'Metrics/ClassLength')
]
end
it 'returns an offense' do
expect(cop.messages)
.to eq(['Unnecessary disabling of `Metrics/MethodLength`.',
'Unnecessary disabling of `Lint/Debugger`.',
'Unnecessary disabling of `Lint/AmbiguousOperator`.'])
expect(cop.highlights).to eq(['Metrics/MethodLength',
'Lint/Debugger',
'Lint/AmbiguousOperator'])
end
it 'autocorrects' do
expect(corrected_source).to eq(
'# rubocop:disable Metrics/ClassLength'
)
end
end
context 'multiple cops, and the leftmost one has no offenses' do
let(:source) do
'# rubocop:disable Metrics/ClassLength, Metrics/MethodLength'
end
let(:cop_disabled_line_ranges) do
{ 'Metrics/ClassLength' => [1..Float::INFINITY],
'Metrics/MethodLength' => [1..Float::INFINITY] }
end
let(:offenses) do
[
RuboCop::Cop::Offense.new(:convention,
OpenStruct.new(line: 7, column: 0),
'Method has too many lines.',
'Metrics/MethodLength')
]
end
it 'returns an offense' do
expect(cop.messages)
.to eq(['Unnecessary disabling of `Metrics/ClassLength`.'])
expect(cop.highlights).to eq(['Metrics/ClassLength'])
end
it 'autocorrects' do
expect(corrected_source).to eq(
'# rubocop:disable Metrics/MethodLength'
)
end
end
context 'multiple cops, with abbreviated names' do
context 'one of them has offenses' do
let(:source) do
'# rubocop:disable MethodLength, ClassLength, Debugger'
end
let(:cop_disabled_line_ranges) do
{ 'Metrics/ClassLength' => [1..Float::INFINITY],
'Metrics/MethodLength' => [1..Float::INFINITY],
'Lint/Debugger' => [1..Float::INFINITY] }
end
let(:offenses) do
[
RuboCop::Cop::Offense.new(:convention,
OpenStruct.new(line: 7, column: 0),
'Method has too many lines.',
'Metrics/MethodLength')
]
end
it 'returns an offense' do
expect(cop.messages)
.to eq(['Unnecessary disabling of `Metrics/ClassLength`.',
'Unnecessary disabling of `Lint/Debugger`.'])
expect(cop.highlights).to eq(%w[ClassLength Debugger])
end
end
end
context 'comment is not at the beginning of the file' do
context 'and not all cops have offenses' do
let(:source) do
['puts 1',
'# rubocop:disable MethodLength, ClassLength'].join("\n")
end
let(:cop_disabled_line_ranges) do
{ 'Metrics/ClassLength' => [2..Float::INFINITY],
'Metrics/MethodLength' => [2..Float::INFINITY] }
end
let(:offenses) do
[
RuboCop::Cop::Offense.new(:convention,
OpenStruct.new(line: 7, column: 0),
'Method has too many lines.',
'Metrics/MethodLength')
]
end
it 'registers an offense' do
expect(cop.messages).to eq(
['Unnecessary disabling of `Metrics/ClassLength`.']
)
expect(cop.highlights).to eq(['ClassLength'])
end
end
end
context 'misspelled cops' do
let(:source) do
'# rubocop:disable Metrics/MethodLenght, KlassLength'
end
let(:cop_disabled_line_ranges) do
{ 'KlassLength' => [1..Float::INFINITY],
'Metrics/MethodLenght' => [1..Float::INFINITY] }
end
it 'returns an offense' do
expect(cop.messages)
.to eq(['Unnecessary disabling of `KlassLength` (unknown ' \
'cop), `Metrics/MethodLenght` (did you mean ' \
'`Metrics/MethodLength`?).'])
end
end
context 'all cops' do
let(:source) { '# rubocop:disable all' }
let(:cop_disabled_line_ranges) do
{
'Metrics/MethodLength' => [1..Float::INFINITY],
'Metrics/ClassLength' => [1..Float::INFINITY],
'Lint/UnneededDisable' => [1..Float::INFINITY]
# etc... (no need to include all cops here)
}
end
it 'returns an offense' do
expect(cop.messages).to eq(['Unnecessary disabling of all cops.'])
expect(cop.highlights).to eq(['# rubocop:disable all'])
end
end
end
end
context 'and there are two offenses' do
let(:message) do
'Replace class var @@class_var with a class instance var.'
end
let(:cop_name) { 'Style/ClassVars' }
let(:offenses) do
offense_lines.map do |line|
RuboCop::Cop::Offense.new(:convention,
OpenStruct.new(line: line, column: 3),
message,
cop_name)
end
end
context 'and a comment disables' do
context 'one cop twice' do
let(:source) do
['class One',
' # rubocop:disable Style/ClassVars',
' @@class_var = 1',
'end',
'',
'class Two',
' # rubocop:disable Style/ClassVars',
' @@class_var = 2',
'end'].join("\n")
end
let(:offense_lines) { [3, 8] }
let(:cop_disabled_line_ranges) do
{ 'Style/ClassVars' => [2..7, 7..9] }
end
it 'returns an offense' do
expect(cop.messages)
.to eq(['Unnecessary disabling of `Style/ClassVars`.'])
expect(cop.highlights)
.to eq(['# rubocop:disable Style/ClassVars'])
end
end
context 'one cop and then all cops' do
let(:source) do
['class One',
' # rubocop:disable Style/ClassVars',
' # rubocop:disable all',
' @@class_var = 1',
'end'].join("\n")
end
let(:offense_lines) { [4] }
let(:cop_disabled_line_ranges) do
{ 'Style/ClassVars' => [2..3, 3..Float::INFINITY] }
end
it 'returns an offense' do
expect(cop.messages)
.to eq(['Unnecessary disabling of `Style/ClassVars`.'])
expect(cop.highlights)
.to eq(['# rubocop:disable Style/ClassVars'])
end
end
end
end
context 'and there is an offense' do
let(:offenses) do
[
RuboCop::Cop::Offense.new(:convention,
OpenStruct.new(line: 7, column: 0),
'Tab detected.',
'Style/Tab')
]
end
context 'and a comment disables' do
context 'that cop' do
let(:source) { '# rubocop:disable Style/Tab' }
let(:cop_disabled_line_ranges) { { 'Style/Tab' => [1..100] } }
it 'returns an empty array' do
expect(cop.offenses).to be_empty
end
end
context 'that cop but on other lines' do
let(:source) { ("\n" * 9) << '# rubocop:disable Style/Tab' }
let(:cop_disabled_line_ranges) { { 'Style/Tab' => [10..12] } }
it 'returns an offense' do
expect(cop.messages)
.to eq(['Unnecessary disabling of `Style/Tab`.'])
expect(cop.highlights).to eq(['# rubocop:disable Style/Tab'])
end
end
context 'all cops' do
let(:source) { '# rubocop:disable all' }
let(:cop_disabled_line_ranges) do
{
'Metrics/MethodLength' => [1..Float::INFINITY],
'Metrics/ClassLength' => [1..Float::INFINITY]
# etc... (no need to include all cops here)
}
end
it 'returns an empty array' do
expect(cop.offenses).to be_empty
end
end
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/unneeded_splat_expansion_spec.rb 0000664 0000000 0000000 00000032567 13070542236 0027721 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::UnneededSplatExpansion do
subject(:cop) { described_class.new }
let(:message) { 'Unnecessary splat expansion.' }
let(:array_param_message) { 'Pass array contents as separate arguments.' }
it 'allows assigning to a splat' do
inspect_source(cop, '*, rhs = *node')
expect(cop.offenses).to be_empty
end
it 'allows assigning to a splat variable' do
inspect_source(cop, 'lhs, *args = *node')
expect(cop.offenses).to be_empty
end
it 'allows assigning a variable to a splat expansion of a variable' do
inspect_source(cop, 'a = *b')
expect(cop.offenses).to be_empty
end
it 'allows assigning to an expanded range' do
inspect_source(cop, 'a = *1..10')
expect(cop.offenses).to be_empty
end
it 'allows splat expansion inside of an array' do
inspect_source(cop, 'a = [10, 11, *1..9]')
expect(cop.offenses).to be_empty
end
it 'accepts expanding a variable as a method parameter' do
inspect_source(cop, ['foo = [1, 2, 3]',
'array.push(*foo)'])
expect(cop.offenses).to be_empty
end
shared_examples 'splat literal assignment' do |literal|
it 'registers an offense for ' do
inspect_source(cop, "a = *#{literal}")
expect(cop.messages).to eq([message])
expect(cop.highlights).to eq(["*#{literal}"])
end
end
shared_examples 'array splat expansion' do |literal|
context 'method parameters' do
it 'registers an offense' do
inspect_source(cop, "array.push(*#{literal})")
expect(cop.messages).to eq([array_param_message])
expect(cop.highlights).to eq(["*#{literal}"])
end
end
it_behaves_like 'splat literal assignment', literal
end
shared_examples 'splat expansion' do |literal|
context 'method parameters' do
it 'registers an offense' do
inspect_source(cop, "array.push(*#{literal})")
expect(cop.messages).to eq([message])
expect(cop.highlights).to eq(["*#{literal}"])
end
end
it_behaves_like 'splat literal assignment', literal
end
it_behaves_like 'array splat expansion', '[1, 2, 3]'
it_behaves_like 'array splat expansion', '%w(one two three)'
it_behaves_like 'array splat expansion', '%W(one #{two} three)'
it_behaves_like 'splat expansion', "'a'"
it_behaves_like 'splat expansion', '"#{a}"'
it_behaves_like 'splat expansion', '1'
it_behaves_like 'splat expansion', '1.1'
context 'assignment to splat expansion' do
it 'registers an offense for an array using a constructor' do
inspect_source(cop, 'a = *Array.new(3) { 42 }')
expect(cop.messages).to eq([message])
expect(cop.highlights).to eq(['*Array.new(3) { 42 }'])
end
end
context 'expanding an array literal in a when condition' do
it 'registers an offense for an array using []' do
inspect_source(cop, ['case foo',
'when *[first, second]',
' bar',
'end'])
expect(cop.messages).to eq([message])
expect(cop.highlights).to eq(['*[first, second]'])
end
it 'registers an offense for an array using %w' do
inspect_source(cop, ['case foo',
'when *%w(first second)',
' bar',
'end'])
expect(cop.messages).to eq([message])
expect(cop.highlights).to eq(['*%w(first second)'])
end
it 'registers an offense for an array using %W' do
inspect_source(cop, ['case foo',
'when *%W(#{first} second)',
' bar',
'end'])
expect(cop.messages).to eq([message])
expect(cop.highlights).to eq(['*%W(#{first} second)'])
end
it 'allows an array that is assigned to a variable' do
inspect_source(cop, ['baz = [1, 2, 3]',
'case foo',
'when *baz',
' bar',
'end'])
expect(cop.offenses).to be_empty
end
it 'allows an array using a constructor' do
inspect_source(cop, ['case foo',
'when *Array.new(3) { 42 }',
' bar',
'end'])
expect(cop.offenses).to be_empty
end
end
it 'registers an offense for an array literal being expanded in a rescue' do
inspect_source(cop, ['begin',
' foo',
'rescue *[First, Second]',
' bar',
'end'])
expect(cop.messages).to eq([message])
expect(cop.highlights).to eq(['*[First, Second]'])
end
it 'allows expansions of an array that is assigned to a variable in rescue' do
inspect_source(cop, ['ERRORS = [FirstError, SecondError]',
'begin',
' foo',
'rescue *ERRORS',
' bar',
'end'])
expect(cop.offenses).to be_empty
end
it 'allows an array using a constructor' do
inspect_source(cop, ['begin',
' foo',
'rescue *Array.new(3) { 42 }',
' bad_example',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for the expansion of an array literal' \
'inside of an array literal' do
inspect_source(cop, '[1, 2, *[3, 4, 5], 6, 7]')
expect(cop.messages).to eq([array_param_message])
expect(cop.highlights).to eq(['*[3, 4, 5]'])
end
it 'allows expanding a method call on an array literal' do
inspect_source(cop, '[1, 2, *[3, 4, 5].map(&:to_s), 6, 7]')
expect(cop.offenses).to be_empty
end
context 'autocorrect' do
context 'assignment to a splat expanded variable' do
it 'removes the splat from an array using []' do
new_source = autocorrect_source(cop, 'a = *[1, 2, 3]')
expect(new_source).to eq('a = [1, 2, 3]')
end
it 'removes the splat from an array using %w' do
new_source = autocorrect_source(cop, 'a = *%w(one two three)')
expect(new_source).to eq('a = %w(one two three)')
end
it 'removes the splat from an array using %W' do
new_source = autocorrect_source(cop, 'a = *%W(one two three)')
expect(new_source).to eq('a = %W(one two three)')
end
it 'converts an expanded string to an array' do
new_source = autocorrect_source(cop, "a = *'a'")
expect(new_source).to eq("a = ['a']")
end
it 'converts an expanded string with interpolation to an array' do
new_source = autocorrect_source(cop, 'a = *"#{a}"')
expect(new_source).to eq('a = ["#{a}"]')
end
it 'converts an expanded integer to an array' do
new_source = autocorrect_source(cop, 'a = *1')
expect(new_source).to eq('a = [1]')
end
it 'converts an expanded float to an array' do
new_source = autocorrect_source(cop, 'a = *1.1')
expect(new_source).to eq('a = [1.1]')
end
end
context 'splat expansion in when condition' do
it 'removes the square brackets' do
new_source = autocorrect_source(cop, ['case foo',
'when *[1, 2, 3]',
' bar',
'end'])
expect(new_source).to eq(['case foo',
'when 1, 2, 3',
' bar',
'end'].join("\n"))
end
it 'changes %w to a list of words' do
new_source = autocorrect_source(cop, ['case foo',
'when *%w(one two three)',
' bar',
'end'])
expect(new_source).to eq(['case foo',
"when 'one', 'two', 'three'",
' bar',
'end'].join("\n"))
end
it 'changes %W to a list of words' do
new_source = autocorrect_source(cop, ['case foo',
'when *%W(one #{two} three)',
' bar',
'end'])
expect(new_source).to eq(['case foo',
'when "one", "#{two}", "three"',
' bar',
'end'].join("\n"))
end
end
context 'rescuing splat expansion' do
it 'changes an array literal to a list of constants' do
new_source = autocorrect_source(cop, ['begin',
' foo',
'rescue *[First, Second]',
' bar',
'end'])
expect(new_source).to eq(['begin',
' foo',
'rescue First, Second',
' bar',
'end'].join("\n"))
end
end
context 'splat expansion of method parameters' do
it 'removes the splat and brackets from []' do
new_source = autocorrect_source(cop, 'foo(*[1, 2, 3])')
expect(new_source).to eq('foo(1, 2, 3)')
end
it 'changes %w to a list of words' do
new_source = autocorrect_source(cop, 'foo(*%w(one two three))')
expect(new_source).to eq("foo('one', 'two', 'three')")
end
it 'changes %W to a list of words' do
new_source = autocorrect_source(cop, 'foo(*%W(#{one} two three))')
expect(new_source).to eq('foo("#{one}", "two", "three")')
end
end
context 'splat expansion inside of an array' do
it 'removes the splat and brackets from []' do
new_source = autocorrect_source(cop, '[1, 2, *[3, 4, 5], 6, 7]')
expect(new_source).to eq('[1, 2, 3, 4, 5, 6, 7]')
end
it 'changes %w to a list of words' do
new_source = autocorrect_source(cop, "['a', 'b', *%w(c d e), 'f', 'g']")
expect(new_source).to eq("['a', 'b', 'c', 'd', 'e', 'f', 'g']")
end
it 'changes %W to a list of words' do
new_source = autocorrect_source(cop, '["a", "b", *%W(#{one} two)]')
expect(new_source).to eq('["a", "b", "#{one}", "two"]')
end
end
end
context 'ruby >= 2.0', :ruby20 do
it_behaves_like 'array splat expansion', '%i(first second)'
it_behaves_like 'array splat expansion', '%I(first second #{third})'
context 'arrays being expanded with %i variants using splat expansion' do
it 'registers an offense for an array literal being expanded in a ' \
'when condition' do
inspect_source(cop, ['case foo',
'when *%i(first second)',
' bar',
'when *%I(#{first} second)',
' baz',
'end'])
expect(cop.offenses.size).to eq(2)
expect(cop.highlights).to eq(['*%i(first second)',
'*%I(#{first} second)'])
end
context 'splat expansion of method parameters' do
it 'registers an offense for an array literal %i' do
inspect_source(cop, 'array.push(*%i(first second))')
expect(cop.messages).to eq([array_param_message])
expect(cop.highlights).to eq(['*%i(first second)'])
end
it 'registers an offense for an array literal %I' do
inspect_source(cop, 'array.push(*%I(#{first} second))')
expect(cop.messages).to eq([array_param_message])
expect(cop.highlights).to eq(['*%I(#{first} second)'])
end
end
context 'autocorrect' do
it 'changes %i to a list of symbols' do
new_source = autocorrect_source(cop, ['case foo',
'when *%i(first second)',
' baz',
'end'])
expect(new_source).to eq(['case foo',
'when :first, :second',
' baz',
'end'].join("\n"))
end
it 'changes %I to a list of symbols' do
new_source = autocorrect_source(cop, ['case foo',
'when *%I(#{first} second)',
' baz',
'end'])
expect(new_source).to eq(['case foo',
'when :"#{first}", :"second"',
' baz',
'end'].join("\n"))
end
end
context 'splat expansion inside of an array' do
it 'changes %i to a list of symbols' do
new_source = autocorrect_source(cop, '[:a, :b, *%i(c d), :e]')
expect(new_source).to eq('[:a, :b, :c, :d, :e]')
end
it 'changes %I to a list of symbols' do
new_source = autocorrect_source(cop, '[:a, :b, *%I(#{one} two), :e]')
expect(new_source).to eq('[:a, :b, :"#{one}", :"two", :e]')
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/unreachable_code_spec.rb 0000664 0000000 0000000 00000003024 13070542236 0026070 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::UnreachableCode do
subject(:cop) { described_class.new }
described_class::NODE_TYPES.each do |t|
it "registers an offense for #{t} before other statements" do
inspect_source(cop,
['foo = 5',
t.to_s,
'bar'])
expect(cop.offenses.size).to eq(1)
end
it "accepts code with conditional #{t}" do
inspect_source(cop,
['foo = 5',
"#{t} if test",
'bar'])
expect(cop.offenses).to be_empty
end
it "accepts #{t} as the final expression" do
inspect_source(cop,
['foo = 5',
"#{t} if test"])
expect(cop.offenses).to be_empty
end
end
described_class::FLOW_COMMANDS.each do |t|
it "registers an offense for #{t} before other statements" do
inspect_source(cop,
['foo = 5',
"#{t} something",
'bar'])
expect(cop.offenses.size).to eq(1)
end
it "accepts code with conditional #{t}" do
inspect_source(cop,
['foo = 5',
"#{t} something if test",
'bar'])
expect(cop.offenses).to be_empty
end
it "accepts #{t} as the final expression" do
inspect_source(cop,
['foo = 5',
"#{t} something if test"])
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/unused_block_argument_spec.rb 0000664 0000000 0000000 00000025546 13070542236 0027221 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::UnusedBlockArgument, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'AllowUnusedKeywordArguments' => false } }
context 'inspection' do
before do
inspect_source(cop, source)
end
context 'when a block takes multiple arguments' do
context 'and an argument is unused' do
let(:source) { <<-END }
hash = { foo: 'FOO', bar: 'BAR' }
hash.each do |key, value|
puts key
end
END
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(
'Unused block argument - `value`. ' \
"If it's necessary, use `_` or `_value` as an argument name " \
"to indicate that it won't be used."
)
expect(cop.offenses.first.severity.name).to eq(:warning)
expect(cop.offenses.first.line).to eq(2)
expect(cop.highlights).to eq(['value'])
end
end
context 'and all the arguments are unused' do
let(:source) { <<-END }
hash = { foo: 'FOO', bar: 'BAR' }
hash.each do |key, value|
puts :something
end
END
it 'registers offenses and suggests omitting them' do
expect(cop.offenses.size).to eq(2)
expect(cop.offenses.first.message).to eq(
'Unused block argument - `key`. ' \
"You can omit all the arguments if you don't care about them."
)
expect(cop.offenses.first.line).to eq(2)
expect(cop.highlights).to eq(%w[key value])
end
end
end
context 'when a block takes single argument' do
context 'and the argument is unused' do
let(:source) { <<-END }
1.times do |index|
puts :something
end
END
it 'registers an offense and suggests omitting that' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(
'Unused block argument - `index`. ' \
"You can omit the argument if you don't care about it."
)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['index'])
end
end
context 'and the method call is `define_method`' do
let(:source) { <<-END }
define_method(:foo) do |bar|
puts 'baz'
end
END
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(
'Unused block argument - `bar`. ' \
"If it's necessary, use `_` or `_bar` as an argument name " \
"to indicate that it won't be used."
)
expect(cop.highlights).to eq(['bar'])
end
end
end
context 'when a block have a block local variable' do
context 'and the variable is unused' do
let(:source) { <<-END }
1.times do |index; block_local_variable|
puts index
end
END
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(
'Unused block local variable - `block_local_variable`.'
)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['block_local_variable'])
end
end
end
context 'when a lambda block takes arguments' do
context 'and all the arguments are unused' do
let(:source) { <<-END }
-> (foo, bar) { do_something }
END
it 'registers offenses and suggests using a proc' do
expect(cop.offenses.size).to eq(2)
expect(cop.offenses.first.message).to eq(
'Unused block argument - `foo`. ' \
"If it's necessary, use `_` or `_foo` as an argument name " \
"to indicate that it won't be used. " \
'Also consider using a proc without arguments instead of a ' \
"lambda if you want it to accept any arguments but don't care " \
'about them.'
)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(%w[foo bar])
end
end
context 'and an argument is unused' do
let(:source) { <<-END }
-> (foo, bar) { puts bar }
END
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(
'Unused block argument - `foo`. ' \
"If it's necessary, use `_` or `_foo` as an argument name " \
"to indicate that it won't be used."
)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['foo'])
end
end
end
context 'when an underscore-prefixed block argument is not used' do
let(:source) { <<-END }
1.times do |_index|
puts 'foo'
end
END
it 'accepts' do
expect(cop.offenses).to be_empty
end
end
context 'when an optional keyword argument is unused' do
context 'when the method call is `define_method`' do
let(:source) { <<-END }
define_method(:foo) do |bar: 'default'|
puts 'bar'
end
END
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(
'Unused block argument - `bar`. ' \
"If it's necessary, use `_` or `_bar` as an argument name " \
"to indicate that it won't be used."
)
expect(cop.highlights).to eq(['bar'])
end
context 'when AllowUnusedKeywordArguments set' do
let(:cop_config) { { 'AllowUnusedKeywordArguments' => true } }
it 'does not care' do
expect(cop.offenses).to be_empty
end
end
end
context 'when the method call is not `define_method`' do
let(:source) { <<-END }
foo(:foo) do |bar: 'default'|
puts 'bar'
end
END
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(
'Unused block argument - `bar`. ' \
"You can omit the argument if you don't care about it."
)
expect(cop.highlights).to eq(['bar'])
end
context 'when AllowUnusedKeywordArguments set' do
let(:cop_config) { { 'AllowUnusedKeywordArguments' => true } }
it 'does not care' do
expect(cop.offenses).to be_empty
end
end
end
end
context 'when a method argument is not used' do
let(:source) { <<-END }
def some_method(foo)
end
END
it 'does not care' do
expect(cop.offenses).to be_empty
end
end
context 'when a variable is not used' do
let(:source) { <<-END }
1.times do
foo = 1
end
END
it 'does not care' do
expect(cop.offenses).to be_empty
end
end
context 'in a method calling `binding` without arguments' do
let(:source) { <<-END }
test do |key, value|
puts something(binding)
end
END
it 'accepts all arguments' do
expect(cop.offenses).to be_empty
end
context 'inside a method definition' do
let(:source) { <<-END }
test do |key, value|
def other(a)
puts something(binding)
end
end
END
it 'registers offenses' do
expect(cop.offenses.size).to eq 2
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(%w[key value])
end
end
end
context 'in a method calling `binding` with arguments' do
context 'when a method argument is unused' do
let(:source) { <<-END }
test do |key, value|
puts something(binding(:other))
end
END
it 'registers an offense' do
expect(cop.offenses.size).to eq(2)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(%w[key value])
end
end
end
end
context 'auto-correct' do
it 'fixes single' do
expect(autocorrect_source(cop, <<-SOURCE
arr.map { |foo| stuff }
SOURCE
)).to eq(<<-CORRECTED_SOURCE
arr.map { |_foo| stuff }
CORRECTED_SOURCE
)
end
it 'fixes multiple' do
expect(autocorrect_source(cop, <<-SOURCE
hash.map { |key, val| stuff }
SOURCE
)).to eq(<<-CORRECTED_SOURCE
hash.map { |_key, _val| stuff }
CORRECTED_SOURCE
)
end
it 'preserves whitespace' do
expect(autocorrect_source(cop, <<-SOURCE
hash.map { |key,
val| stuff }
SOURCE
)).to eq(<<-CORRECTED_SOURCE
hash.map { |_key,
_val| stuff }
CORRECTED_SOURCE
)
end
it 'preserves splat' do
expect(autocorrect_source(cop, <<-SOURCE
obj.method { |foo, *bars, baz| stuff(foo, baz) }
SOURCE
)).to eq(<<-CORRECTED_SOURCE
obj.method { |foo, *_bars, baz| stuff(foo, baz) }
CORRECTED_SOURCE
)
end
it 'preserves default' do
expect(autocorrect_source(cop, <<-SOURCE
obj.method { |foo, bar = baz| stuff(foo) }
SOURCE
)).to eq(<<-CORRECTED_SOURCE
obj.method { |foo, _bar = baz| stuff(foo) }
CORRECTED_SOURCE
)
end
it 'ignores used' do
original_source = <<-SOURCE
obj.method { |foo, baz| stuff(foo, baz) }
SOURCE
expect(autocorrect_source(cop, original_source)).to eq(original_source)
end
end
context 'when IgnoreEmptyBlocks config parameter is set' do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'IgnoreEmptyBlocks' => true } }
it 'accepts an empty block with a single unused parameter' do
inspect_source(cop, '->(arg) { }')
expect(cop.offenses).to be_empty
end
it 'registers an offense for a non-empty block with an unused parameter' do
inspect_source(cop, '->(arg) { 1 }')
expect(cop.offenses.size).to eq 1
end
it 'accepts an empty block with multiple unused parameters' do
inspect_source(cop, '->(arg1, arg2, *others) { }')
expect(cop.offenses).to be_empty
end
it 'registers an offense for a non-empty block with multiple unused args' do
inspect_source(cop, '->(arg1, arg2, *others) { 1 }')
expect(cop.offenses.size).to eq 3
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/unused_method_argument_spec.rb 0000664 0000000 0000000 00000023454 13070542236 0027403 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::UnusedMethodArgument, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) do
{ 'AllowUnusedKeywordArguments' => false, 'IgnoreEmptyMethods' => false }
end
describe 'inspection' do
before do
inspect_source(cop, source)
end
context 'when a method takes multiple arguments' do
context 'and an argument is unused' do
let(:source) { <<-END }
def some_method(foo, bar)
puts bar
end
END
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(
'Unused method argument - `foo`. ' \
"If it's necessary, use `_` or `_foo` " \
"as an argument name to indicate that it won't be used."
)
expect(cop.offenses.first.severity.name).to eq(:warning)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['foo'])
end
end
context 'and all the arguments are unused' do
let(:source) { <<-END }
def some_method(foo, bar)
end
END
it 'registers offenses and suggests the use of `*`' do
expect(cop.offenses.size).to eq(2)
expect(cop.offenses.first.message).to eq(
'Unused method argument - `foo`. ' \
"If it's necessary, use `_` or `_foo` " \
"as an argument name to indicate that it won't be used. " \
'You can also write as `some_method(*)` if you want the method ' \
"to accept any arguments but don't care about them."
)
end
end
end
context 'when a required keyword argument is unused', ruby: 2.1 do
let(:source) { <<-END }
def self.some_method(foo, bar:)
puts foo
end
END
it 'registers an offense but does not suggest underscore-prefix' do
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['bar'])
expect(cop.offenses.first.message)
.to eq('Unused method argument - `bar`.')
end
end
context 'when an optional keyword argument is unused' do
let(:source) { <<-END }
def self.some_method(foo, bar: 1)
puts foo
end
END
it 'registers an offense but does not suggest underscore-prefix' do
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['bar'])
expect(cop.offenses.first.message)
.to eq('Unused method argument - `bar`.')
end
context 'and AllowUnusedKeywordArguments set' do
let(:cop_config) { { 'AllowUnusedKeywordArguments' => true } }
it 'does not care' do
expect(cop.offenses).to be_empty
end
end
end
context 'when a singleton method argument is unused' do
let(:source) { <<-END }
def self.some_method(foo)
end
END
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['foo'])
end
end
context 'when an underscore-prefixed method argument is unused' do
let(:source) { <<-END }
def some_method(_foo)
end
END
it 'accepts' do
expect(cop.offenses).to be_empty
end
end
context 'when a method argument is used' do
let(:source) { <<-END }
def some_method(foo)
puts foo
end
END
it 'accepts' do
expect(cop.offenses).to be_empty
end
end
context 'when a variable is unused' do
let(:source) { <<-END }
def some_method
foo = 1
end
END
it 'does not care' do
expect(cop.offenses).to be_empty
end
end
context 'when a block argument is unused' do
let(:source) { <<-END }
1.times do |foo|
end
END
it 'does not care' do
expect(cop.offenses).to be_empty
end
end
context 'in a method calling `super` without arguments' do
context 'when a method argument is not used explicitly' do
let(:source) { <<-END }
def some_method(foo)
super
end
END
it 'accepts since the arguments are guaranteed to be the same as ' \
"superclass' ones and the user has no control on them" do
expect(cop.offenses).to be_empty
end
end
end
context 'in a method calling `super` with arguments' do
context 'when a method argument is unused' do
let(:source) { <<-END }
def some_method(foo)
super(:something)
end
END
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['foo'])
end
end
end
context 'in a method calling `binding` without arguments' do
let(:source) { <<-END }
def some_method(foo, bar)
do_something binding
end
END
it 'accepts all arguments' do
expect(cop.offenses).to be_empty
end
context 'inside another method definition' do
let(:source) { <<-END }
def some_method(foo, bar)
def other(a)
puts something(binding)
end
end
END
it 'registers offenses' do
expect(cop.offenses.size).to eq 2
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(%w[foo bar])
end
end
end
context 'in a method calling `binding` with arguments' do
context 'when a method argument is unused' do
let(:source) { <<-END }
def some_method(foo)
binding(:something)
end
END
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['foo'])
end
end
end
end
describe 'auto-correction' do
let(:corrected_source) { autocorrect_source(cop, source) }
context 'when multiple arguments are unused' do
let(:source) { <<-END }
def some_method(foo, bar)
end
END
let(:expected_source) { <<-END }
def some_method(_foo, _bar)
end
END
it 'adds underscore-prefix to them' do
expect(corrected_source).to eq(expected_source)
end
end
context 'when only a part of arguments is unused' do
let(:source) { <<-END }
def some_method(foo, bar)
puts foo
end
END
let(:expected_source) { <<-END }
def some_method(foo, _bar)
puts foo
end
END
it 'modifies only the unused one' do
expect(corrected_source).to eq(expected_source)
end
end
context 'when there is some whitespace around the argument' do
let(:source) { <<-END }
def some_method(foo,
bar)
puts foo
end
END
let(:expected_source) { <<-END }
def some_method(foo,
_bar)
puts foo
end
END
it 'preserves the whitespace' do
expect(corrected_source).to eq(expected_source)
end
end
context 'when a splat argument is unused' do
let(:source) { <<-END }
def some_method(foo, *bar)
puts foo
end
END
let(:expected_source) { <<-END }
def some_method(foo, *_bar)
puts foo
end
END
it 'preserves the splat' do
expect(corrected_source).to eq(expected_source)
end
end
context 'when an unused argument has default value' do
let(:source) { <<-END }
def some_method(foo, bar = 1)
puts foo
end
END
let(:expected_source) { <<-END }
def some_method(foo, _bar = 1)
puts foo
end
END
it 'preserves the default value' do
expect(corrected_source).to eq(expected_source)
end
end
context 'when a keyword argument is unused' do
let(:source) { <<-END }
def some_method(foo, bar: 1)
puts foo
end
END
it 'ignores that since modifying the name changes the method interface' do
expect(corrected_source).to eq(source)
end
end
context 'when a trailing block argument is unused' do
let(:source) { <<-END }
def some_method(foo, bar, &block)
foo + bar
end
END
let(:expected_source) { <<-END }
def some_method(foo, bar)
foo + bar
end
END
it 'removes the unused block arg' do
expect(corrected_source).to eq(expected_source)
end
end
end
context 'when IgnoreEmptyMethods config parameter is set' do
let(:cop_config) { { 'IgnoreEmptyMethods' => true } }
it 'accepts an empty method with a single unused parameter' do
inspect_source(cop, ['def method(arg)',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for a non-empty method with a single unused ' \
'parameter' do
inspect_source(cop, ['def method(arg)',
' 1',
'end'])
expect(cop.offenses.size).to eq 1
end
it 'accepts an empty method with multiple unused parameters' do
inspect_source(cop, ['def method(a, b, *others)',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for a non-empty method with multiple unused ' \
'parameters' do
inspect_source(cop, ['def method(a, b, *others)',
' 1',
'end'])
expect(cop.offenses.size).to eq 3
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/useless_access_modifier_spec.rb 0000664 0000000 0000000 00000061414 13070542236 0027516 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::UselessAccessModifier do
let(:config) { RuboCop::Config.new }
subject(:cop) { described_class.new(config) }
context 'when an access modifier has no effect' do
let(:source) do
[
'class SomeClass',
' def some_method',
' puts 10',
' end',
' private',
' def self.some_method',
' puts 10',
' end',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless `private` access modifier.')
expect(cop.offenses.first.line).to eq(5)
expect(cop.highlights).to eq(['private'])
end
end
context 'when an access modifier has no methods' do
let(:source) do
[
'class SomeClass',
' def some_method',
' puts 10',
' end',
' protected',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless `protected` access modifier.')
expect(cop.offenses.first.line).to eq(5)
expect(cop.highlights).to eq(['protected'])
end
end
context 'when an access modifier is followed by attr_*' do
let(:source) do
[
'class SomeClass',
' protected',
' attr_accessor :some_property',
' public',
' attr_reader :another_one',
' private',
' attr :yet_again, true',
' protected',
' attr_writer :just_for_good_measure',
'end'
]
end
it 'does not register an offense' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
context 'when an access modifier is followed by a ' \
'class method defined on constant' do
let(:source) do
[
'class SomeClass',
' protected',
' def SomeClass.some_method',
' end',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless `protected` access modifier.')
expect(cop.offenses.first.line).to eq(2)
expect(cop.highlights).to eq(['protected'])
end
end
context 'when there are consecutive access modifiers' do
let(:source) do
[
'class SomeClass',
' private',
' private',
' def some_method',
' puts 10',
' end',
' def some_other_method',
' puts 10',
' end',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless `private` access modifier.')
expect(cop.offenses.first.line).to eq(3)
expect(cop.highlights).to eq(['private'])
end
end
context 'when passing method as symbol' do
let(:source) do
[
'class SomeClass',
' def some_method',
' puts 10',
' end',
' private :some_method',
'end'
]
end
it 'does not register an offense' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
context 'when class is empty save modifier' do
let(:source) do
[
'class SomeClass',
' private',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless `private` access modifier.')
expect(cop.offenses.first.line).to eq(2)
expect(cop.highlights).to eq(['private'])
end
end
context 'when multiple class definitions in file but only one has offense' do
let(:source) do
[
'class SomeClass',
' private',
'end',
'class SomeOtherClass',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless `private` access modifier.')
expect(cop.offenses.first.line).to eq(2)
expect(cop.highlights).to eq(['private'])
end
end
if RUBY_ENGINE == 'ruby' && RUBY_VERSION.start_with?('2.1')
context 'ruby 2.1 style modifiers' do
let(:source) do
[
'class SomeClass',
' private def some_method',
' puts 10',
' end',
'end'
]
end
it 'does not register an offense' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
context 'when only a constant or local variable is defined after the ' \
'modifier' do
%w[CONSTANT some_var].each do |binding_name|
let(:source) do
[
'class SomeClass',
' private',
" #{binding_name} = 1",
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
end
end
context 'when a def is an argument to a method call' do
let(:source) do
[
'class SomeClass',
' private',
' helper_method def some_method',
' puts 10',
' end',
'end'
]
end
it 'does not register an offense' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
context "when using ActiveSupport's `concerning` method" do
let(:config) do
RuboCop::Config.new(
'Lint/UselessAccessModifier' => {
'ContextCreatingMethods' => ['concerning']
}
)
end
it 'is aware that this creates a new scope' do
src = ['class SomeClass',
' concerning :FirstThing do',
' def foo',
' end',
' private',
'',
' def method',
' end',
' end',
'',
' concerning :SecondThing do',
' def omg',
' end',
' private',
' def method',
' end',
' end',
' end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'still points out redundant uses within the block' do
src = ['class SomeClass',
' concerning :FirstThing do',
' def foo',
' end',
' private',
'',
' def method',
' end',
' end',
'',
' concerning :SecondThing do',
' def omg',
' end',
' private',
' def method',
' end',
' private',
' def another_method',
' end',
' end',
' end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line).to eq(17)
end
end
context 'when using ActiveSupport behavior when Rails is not eabled' do
it 'reports offenses' do
src = ['module SomeModule',
' extend ActiveSupport::Concern',
' class_methods do',
' def some_public_class_method',
' end',
' private',
' def some_private_class_method',
' end',
' end',
' def some_public_instance_method',
' end',
' private',
' def some_private_instance_method',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
end
context 'when using the class_methods method from ActiveSupport::Concern' do
let(:config) do
RuboCop::Config.new(
'Lint/UselessAccessModifier' => {
'ContextCreatingMethods' => ['class_methods']
}
)
end
it 'is aware that this creates a new scope' do
src = ['module SomeModule',
' extend ActiveSupport::Concern',
' class_methods do',
' def some_public_class_method',
' end',
' private',
' def some_private_class_method',
' end',
' end',
' def some_public_instance_method',
' end',
' private',
' def some_private_instance_method',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
end
context 'when using a known method-creating method' do
let(:config) do
RuboCop::Config.new(
'Lint/UselessAccessModifier' => {
'MethodCreatingMethods' => ['delegate']
}
)
end
it 'is aware that this creates a new method' do
src = ['class SomeClass',
' private',
' ',
' delegate :foo, to: :bar',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'still points out redundant uses within the module' do
src = ['class SomeClass',
' delegate :foo, to: :bar',
' ',
' private',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line).to eq(4)
end
end
shared_examples 'at the top of the body' do |keyword|
it 'registers an offense for `public`' do
src = ["#{keyword} A",
' public',
' def method',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it "doesn't register an offense for `protected`" do
src = ["#{keyword} A",
' protected',
' def method',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it "doesn't register an offense for `private`" do
src = ["#{keyword} A",
' private',
' def method',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
end
shared_examples 'repeated visibility modifiers' do |keyword, modifier|
it "registers an offense when `#{modifier}` is repeated" do
src = ["#{keyword} A",
" #{modifier == 'private' ? 'protected' : 'private'}",
' def method1',
' end',
" #{modifier}",
" #{modifier}",
' def method2',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
end
shared_examples 'non-repeated visibility modifiers' do |keyword|
it 'registers an offense even when `public` is not repeated' do
src = ["#{keyword} A",
' def method1',
' end',
' public',
' def method2',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it "doesn't register an offense when `protected` is not repeated" do
src = ["#{keyword} A",
' def method1',
' end',
' protected',
' def method2',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it "doesn't register an offense when `private` is not repeated" do
src = ["#{keyword} A",
' def method1',
' end',
' private',
' def method2',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
end
shared_examples 'at the end of the body' do |keyword, modifier|
it "registers an offense for trailing `#{modifier}`" do
src = ["#{keyword} A",
' def method1',
' end',
' def method2',
' end',
" #{modifier}",
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
end
shared_examples 'nested in a begin..end block' do |keyword, modifier|
it "still flags repeated `#{modifier}`" do
src = ["#{keyword} A",
" #{modifier == 'private' ? 'protected' : 'private'}",
' def blah',
' end',
' begin',
' def method1',
' end',
" #{modifier}",
" #{modifier}",
' def method2',
' end',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
unless modifier == 'public'
it "doesn't flag an access modifier from surrounding scope" do
src = ["#{keyword} A",
" #{modifier}",
' begin',
' def method1',
' end',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
end
end
shared_examples 'unused visibility modifiers' do |keyword|
it 'registers an error when visibility is immediately changed ' \
'without any intervening defs' do
src = ["#{keyword} A",
' private',
' def method1',
' end',
' public', # bad
' private',
' def method2',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
end
shared_examples 'access modifiers with argument' do |keyword|
it "doesn't register an offense" do
src = ["#{keyword} A",
' def method1',
' end',
' private :method1',
' def method2',
' end',
' public :method2',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
end
shared_examples 'conditionally defined method' do |keyword, modifier|
%w[if unless].each do |conditional_type|
it "doesn't register an offense for #{conditional_type}" do
src = ["#{keyword} A",
" #{modifier}",
" #{conditional_type} x",
' def method1',
' end',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
end
end
shared_examples 'methods defined in an iteration' do |keyword, modifier|
%w[each map].each do |iteration_method|
it "doesn't register an offense for #{iteration_method}" do
src = ["#{keyword} A",
" #{modifier}",
" [1, 2].#{iteration_method} do |i|",
' define_method("method#{i}") do',
' i',
' end',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
end
end
shared_examples 'method defined with define_method' do |keyword, modifier|
it "doesn't register an offense if a block is passed" do
src = ["#{keyword} A",
" #{modifier}",
' define_method(:method1) do',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
%w[lambda proc ->].each do |proc_type|
it "doesn't register an offense if a #{proc_type} is passed" do
src = ["#{keyword} A",
" #{modifier}",
" define_method(:method1, #{proc_type} { })",
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
end
end
shared_examples 'method defined on a singleton class' do |keyword, modifier|
context 'inside a class' do
it "doesn't register an offense if a method is defined" do
src = ["#{keyword} A",
' class << self',
" #{modifier}",
' define_method(:method1) do',
' end',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it "doesn't register an offense if the modifier is the same as " \
'outside the meta-class' do
src = ["#{keyword} A",
" #{modifier}",
' def method1',
' end',
' class << self',
" #{modifier}",
' def method2',
' end',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'registers an offense if no method is defined' do
src = ["#{keyword} A",
' class << self',
" #{modifier}",
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense if no method is defined after the modifier' do
src = ["#{keyword} A",
' class << self',
' def method1',
' end',
" #{modifier}",
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense even if a non-singleton-class method is ' \
'defined' do
src = ["#{keyword} A",
' def method1',
' end',
' class << self',
" #{modifier}",
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
end
context 'outside a class' do
it "doesn't register an offense if a method is defined" do
src = ['class << A',
" #{modifier}",
' define_method(:method1) do',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'registers an offense if no method is defined' do
src = ['class << A',
" #{modifier}",
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense if no method is defined after the modifier' do
src = ['class << A',
' def method1',
' end',
" #{modifier}",
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
end
end
shared_examples 'method defined using class_eval' do |modifier|
it "doesn't register an offense if a method is defined" do
src = ['A.class_eval do',
" #{modifier}",
' define_method(:method1) do',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'registers an offense if no method is defined' do
src = ['A.class_eval do',
" #{modifier}",
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
context 'inside a class' do
it 'registers an offense when a modifier is ouside the block and a ' \
'method is defined only inside the block' do
src = ['class A',
" #{modifier}",
' A.class_eval do',
' def method1',
' end',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'registers two offenses when a modifier is inside and outside the ' \
' and no method is defined' do
src = ['class A',
" #{modifier}",
' A.class_eval do',
" #{modifier}",
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(2)
end
end
end
shared_examples 'def in new block' do |klass, modifier|
it "doesn't register an offense if a method is defined in #{klass}.new" do
src = ["#{klass}.new do",
" #{modifier}",
' def foo',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it "registers an offense if no method is defined in #{klass}.new" do
src = ["#{klass}.new do",
" #{modifier}",
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
end
shared_examples 'method defined using instance_eval' do |modifier|
it "doesn't register an offense if a method is defined" do
src = ['A.instance_eval do',
" #{modifier}",
' define_method(:method1) do',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'registers an offense if no method is defined' do
src = ['A.instance_eval do',
" #{modifier}",
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
context 'inside a class' do
it 'registers an offense when a modifier is ouside the block and a ' \
'method is defined only inside the block' do
src = ['class A',
" #{modifier}",
' self.instance_eval do',
' def method1',
' end',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'registers two offenses when a modifier is inside and outside the ' \
' and no method is defined' do
src = ['class A',
" #{modifier}",
' self.instance_eval do',
" #{modifier}",
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(2)
end
end
end
shared_examples 'nested modules' do |keyword, modifier|
it "doesn't register an offense for nested #{keyword}s" do
src = ["#{keyword} A",
" #{modifier}",
' def method1',
' end',
" #{keyword} B",
' def method2',
' end',
" #{modifier}",
' def method3',
' end',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
context 'unused modifiers' do
it "registers an offense with a nested #{keyword}" do
src = ["#{keyword} A",
" #{modifier}",
" #{keyword} B",
" #{modifier}",
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(2)
end
it "registers an offense when outside a nested #{keyword}" do
src = ["#{keyword} A",
" #{modifier}",
" #{keyword} B",
' def method1',
' end',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it "registers an offense when inside a nested #{keyword}" do
src = ["#{keyword} A",
" #{keyword} B",
" #{modifier}",
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
end
end
%w[protected private].each do |modifier|
it_behaves_like('method defined using class_eval', modifier)
it_behaves_like('method defined using instance_eval', modifier)
end
%w[Class Module Struct].each do |klass|
%w[protected private].each do |modifier|
it_behaves_like('def in new block', klass, modifier)
end
end
%w[module class].each do |keyword|
it_behaves_like('at the top of the body', keyword)
it_behaves_like('non-repeated visibility modifiers', keyword)
it_behaves_like('unused visibility modifiers', keyword)
%w[public protected private].each do |modifier|
it_behaves_like('repeated visibility modifiers', keyword, modifier)
it_behaves_like('at the end of the body', keyword, modifier)
it_behaves_like('nested in a begin..end block', keyword, modifier)
next if modifier == 'public'
it_behaves_like('conditionally defined method', keyword, modifier)
it_behaves_like('methods defined in an iteration', keyword, modifier)
it_behaves_like('method defined with define_method', keyword, modifier)
it_behaves_like('method defined on a singleton class', keyword, modifier)
it_behaves_like('nested modules', keyword, modifier)
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/useless_assignment_spec.rb 0000664 0000000 0000000 00000137616 13070542236 0026557 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::UselessAssignment do
subject(:cop) { described_class.new }
context 'when a variable is assigned and unreferenced in a method' do
let(:source) do
[
'class SomeClass',
' foo = 1',
' puts foo',
' def some_method',
' foo = 2',
' bar = 3',
' puts bar',
' end',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(5)
expect(cop.highlights).to eq(['foo'])
end
include_examples 'mimics MRI 2.1'
end
context 'when a variable is assigned and unreferenced ' \
'in a singleton method defined with self keyword' do
let(:source) do
[
'class SomeClass',
' foo = 1',
' puts foo',
' def self.some_method',
' foo = 2',
' bar = 3',
' puts bar',
' end',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(5)
expect(cop.highlights).to eq(['foo'])
end
include_examples 'mimics MRI 2.1'
end
context 'when a variable is assigned and unreferenced ' \
'in a singleton method defined with variable name' do
let(:source) do
[
'1.times do',
' foo = 1',
' puts foo',
' instance = Object.new',
' def instance.some_method',
' foo = 2',
' bar = 3',
' puts bar',
' end',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(6)
expect(cop.highlights).to eq(['foo'])
end
include_examples 'mimics MRI 2.1'
end
context 'when a variable is assigned and unreferenced in a class' do
let(:source) do
[
'1.times do',
' foo = 1',
' puts foo',
' class SomeClass',
' foo = 2',
' bar = 3',
' puts bar',
' end',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(5)
expect(cop.highlights).to eq(['foo'])
end
include_examples 'mimics MRI 2.1'
end
context 'when a variable is assigned and unreferenced in a class ' \
'subclassing another class stored in local variable' do
let(:source) do
[
'1.times do',
' foo = 1',
' puts foo',
' array_class = Array',
' class SomeClass < array_class',
' foo = 2',
' bar = 3',
' puts bar',
' end',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(6)
expect(cop.highlights).to eq(['foo'])
end
include_examples 'mimics MRI 2.1'
end
context 'when a variable is assigned and unreferenced ' \
'in a singleton class' do
let(:source) do
[
'1.times do',
' foo = 1',
' puts foo',
' instance = Object.new',
' class << instance',
' foo = 2',
' bar = 3',
' puts bar',
' end',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(6)
expect(cop.highlights).to eq(['foo'])
end
include_examples 'mimics MRI 2.1'
end
context 'when a variable is assigned and unreferenced in a module' do
let(:source) do
[
'1.times do',
' foo = 1',
' puts foo',
' module SomeModule',
' foo = 2',
' bar = 3',
' puts bar',
' end',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(5)
expect(cop.highlights).to eq(['foo'])
end
include_examples 'mimics MRI 2.1'
end
context 'when a variable is assigned and unreferenced in top level' do
let(:source) do
[
'foo = 1',
'bar = 2',
'puts bar'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['foo'])
end
include_examples 'mimics MRI 2.1'
end
context 'when a variable is assigned with operator assignment ' \
'in top level' do
let(:source) do
'foo ||= 1'
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(
'Useless assignment to variable - `foo`. Use `||` instead of `||=`.'
)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['foo'])
end
end
context 'when a variable is assigned multiple times ' \
'but unreferenced' do
let(:source) do
[
'def some_method',
' foo = 1',
' bar = 2',
' foo = 3',
' puts bar',
'end'
]
end
it 'registers offenses for each assignment' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(2)
expect(cop.offenses[0].message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses[0].line).to eq(2)
expect(cop.offenses[1].message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses[1].line).to eq(4)
expect(cop.highlights).to eq(%w[foo foo])
end
end
context 'when a referenced variable is reassigned ' \
'but not re-referenced' do
let(:source) do
[
'def some_method',
' foo = 1',
' puts foo',
' foo = 3',
'end'
]
end
it 'registers an offense for the non-re-referenced assignment' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(4)
expect(cop.highlights).to eq(['foo'])
end
end
context 'when an unreferenced variable is reassigned ' \
'and re-referenced' do
let(:source) do
[
'def some_method',
' foo = 1',
' foo = 3',
' puts foo',
'end'
]
end
it 'registers an offense for the unreferenced assignment' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(2)
expect(cop.highlights).to eq(['foo'])
end
end
context 'when an unreferenced variable is reassigned in a block' do
let(:source) do
[
'def const_name(node)',
' const_names = []',
' const_node = node',
'',
' loop do',
' namespace_node, name = *const_node',
' const_names << name',
' break unless namespace_node',
' break if namespace_node.type == :cbase',
' const_node = namespace_node',
' end',
'',
" const_names.reverse.join('::')",
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a referenced variable is reassigned in a block' do
let(:source) do
[
'def some_method',
' foo = 1',
' puts foo',
' 1.times do',
' foo = 2',
' end',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a block local variable is declared but not assigned' do
let(:source) do
[
'1.times do |i; foo|',
'end'
]
end
include_examples 'accepts'
end
context 'when a block local variable is assigned and unreferenced' do
let(:source) do
[
'1.times do |i; foo|',
' foo = 2',
'end'
]
end
it 'registers offenses for the assignment' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(2)
expect(cop.highlights).to eq(['foo'])
end
end
context 'when a variable is assigned in loop body and unreferenced' do
let(:source) do
[
'def some_method',
' while true',
' foo = 1',
' end',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(3)
expect(cop.highlights).to eq(['foo'])
end
include_examples 'mimics MRI 2.1'
end
context 'when a variable is reassigned at the end of loop body ' \
'and would be referenced in next iteration' do
let(:source) do
[
'def some_method',
' total = 0',
' foo = 0',
'',
' while total < 100',
' total += foo',
' foo += 1',
' end',
'',
' total',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a variable is reassigned at the end of loop body ' \
'and would be referenced in loop condition' do
let(:source) do
[
'def some_method',
' total = 0',
' foo = 0',
'',
' while foo < 100',
' total += 1',
' foo += 1',
' end',
'',
' total',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a setter is invoked with operator assignment in loop body' do
let(:source) do
[
'def some_method',
' obj = {}',
'',
' while obj[:count] < 100',
' obj[:count] += 1',
' end',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context "when a variable is reassigned in loop body but won't " \
'be referenced either next iteration or loop condition' do
let(:source) do
[
'def some_method',
' total = 0',
' foo = 0',
'',
' while total < 100',
' total += 1',
' foo += 1',
' end',
'',
' total',
'end'
]
end
it 'registers an offense' do
pending 'Requires an advanced logic that checks whether the return ' \
'value of an operator assignment is used or not.'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(7)
expect(cop.highlights).to eq(['foo'])
end
end
context 'when a referenced variable is reassigned ' \
'but not re-referenced in a method defined in loop' do
let(:source) do
[
'while true',
' def some_method',
' foo = 1',
' puts foo',
' foo = 3',
' end',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(5)
expect(cop.highlights).to eq(['foo'])
end
end
context 'when a variable that has same name as outer scope variable ' \
'is not referenced in a method defined in loop' do
let(:source) do
[
'foo = 1',
'',
'while foo < 100',
' foo += 1',
' def some_method',
' foo = 1',
' end',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(6)
expect(cop.highlights).to eq(['foo'])
end
end
context 'when a variable is assigned in single branch if ' \
'and unreferenced' do
let(:source) do
[
'def some_method(flag)',
' if flag',
' foo = 1',
' end',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(3)
expect(cop.highlights).to eq(['foo'])
end
include_examples 'mimics MRI 2.1'
end
context 'when a unreferenced variable is reassigned in same branch ' \
'and referenced after the branching' do
let(:source) do
[
'def some_method(flag)',
' if flag',
' foo = 1',
' foo = 2',
' end',
'',
' foo',
'end'
]
end
it 'registers an offense for the unreferenced assignment' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(3)
expect(cop.highlights).to eq(['foo'])
end
end
context 'when a variable is reassigned in single branch if ' \
'and referenced after the branching' do
let(:source) do
[
'def some_method(flag)',
' foo = 1',
'',
' if flag',
' foo = 2',
' end',
'',
' foo',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a variable is reassigned in a loop' do
context 'while loop' do
let(:source) do
[
'def while(param)',
' ret = 1',
'',
' while param != 10',
' param += 2',
' ret = param + 1',
' end',
'',
' ret',
'end'
]
end
include_examples 'accepts'
end
context 'post while loop' do
let(:source) do
[
'def post_while(param)',
' ret = 1',
'',
' begin',
' param += 2',
' ret = param + 1',
' end while param < 40',
'',
' ret',
'end'
]
end
include_examples 'accepts'
end
context 'until loop' do
let(:source) do
[
'def until(param)',
' ret = 1',
'',
' until param == 10',
' param += 2',
' ret = param + 1',
' end',
'',
' ret',
'end'
]
end
include_examples 'accepts'
end
context 'post until loop' do
let(:source) do
[
'def post_until(param)',
' ret = 1',
'',
' begin',
' param += 2',
' ret = param + 1',
' end until param == 10',
'',
' ret',
'end'
]
end
include_examples 'accepts'
end
context 'for loop' do
let(:source) do
[
'def for(param)',
' ret = 1',
'',
' for x in param...10',
' param += x',
' ret = param + 1',
' end',
'',
' ret',
'end'
]
end
include_examples 'accepts'
end
end
context 'when a variable is assigned in each branch of if ' \
'and referenced after the branching' do
let(:source) do
[
'def some_method(flag)',
' if flag',
' foo = 2',
' else',
' foo = 3',
' end',
'',
' foo',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a variable is reassigned in single branch if ' \
'and referenced in the branch' do
let(:source) do
[
'def some_method(flag)',
' foo = 1',
'',
' if flag',
' foo = 2',
' puts foo',
' end',
'end'
]
end
it 'registers an offense for the unreferenced assignment' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(2)
expect(cop.highlights).to eq(['foo'])
end
end
context 'when a variable is assigned in each branch of if ' \
'and referenced in the else branch' do
let(:source) do
[
'def some_method(flag)',
' if flag',
' foo = 2',
' else',
' foo = 3',
' puts foo',
' end',
'end'
]
end
it 'registers an offense for the assignment in the if branch' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(3)
expect(cop.highlights).to eq(['foo'])
end
end
context 'when a variable is reassigned and unreferenced in a if branch ' \
'while the variable is referenced in the paired else branch ' do
let(:source) do
[
'def some_method(flag)',
' foo = 1',
'',
' if flag',
' puts foo',
' foo = 2',
' else',
' puts foo',
' end',
'end'
]
end
it 'registers an offense for the reassignment in the if branch' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(6)
expect(cop.highlights).to eq(['foo'])
end
end
context "when there's an unreferenced assignment in top level if branch " \
'while the variable is referenced in the paired else branch' do
let(:source) do
[
'if flag',
' foo = 1',
'else',
' puts foo',
'end'
]
end
it 'registers an offense for the assignment in the if branch' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(2)
expect(cop.highlights).to eq(['foo'])
end
end
context "when there's an unreferenced reassignment in a if branch " \
'while the variable is referenced in the paired elsif branch' do
let(:source) do
[
'def some_method(flag_a, flag_b)',
' foo = 1',
'',
' if flag_a',
' puts foo',
' foo = 2',
' elsif flag_b',
' puts foo',
' end',
'end'
]
end
it 'registers an offense for the reassignment in the if branch' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(6)
expect(cop.highlights).to eq(['foo'])
end
end
context "when there's an unreferenced reassignment in a if branch " \
'while the variable is referenced in a case branch ' \
'in the paired else branch' do
let(:source) do
[
'def some_method(flag_a, flag_b)',
' foo = 1',
'',
' if flag_a',
' puts foo',
' foo = 2',
' else',
' case',
' when flag_b',
' puts foo',
' end',
' end',
'end'
]
end
it 'registers an offense for the reassignment in the if branch' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(6)
expect(cop.highlights).to eq(['foo'])
end
end
context 'when an assignment in a if branch is referenced ' \
'in another if branch' do
let(:source) do
[
'def some_method(flag_a, flag_b)',
' if flag_a',
' foo = 1',
' end',
'',
' if flag_b',
' puts foo',
' end',
'end'
]
end
include_examples 'accepts'
end
context 'when a variable is assigned in branch of modifier if ' \
'that references the variable in its conditional clause' \
'and referenced after the branching' do
let(:source) do
[
'def some_method(flag)',
' foo = 1 unless foo',
' puts foo',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a variable is assigned in branch of modifier if ' \
'that references the variable in its conditional clause' \
'and unreferenced' do
let(:source) do
[
'def some_method(flag)',
' foo = 1 unless foo',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(2)
expect(cop.highlights).to eq(['foo'])
end
end
context 'when a variable is assigned on each side of && ' \
'and referenced after the &&' do
let(:source) do
[
'def some_method',
' (foo = do_something_returns_object_or_nil) && (foo = 1)',
' foo',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a unreferenced variable is reassigned ' \
'on the left side of && and referenced after the &&' do
let(:source) do
[
'def some_method',
' foo = 1',
' (foo = do_something_returns_object_or_nil) && do_something',
' foo',
'end'
]
end
it 'registers an offense for the unreferenced assignment' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(2)
expect(cop.highlights).to eq(['foo'])
end
end
context 'when a unreferenced variable is reassigned ' \
'on the right side of && and referenced after the &&' do
let(:source) do
[
'def some_method',
' foo = 1',
' do_something_returns_object_or_nil && foo = 2',
' foo',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a variable is reassigned ' \
'while referencing itself in rhs and referenced' do
let(:source) do
[
'def some_method',
' foo = [1, 2]',
' foo = foo.map { |i| i + 1 }',
' puts foo',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a variable is reassigned ' \
'with binary operator assignment and referenced' do
let(:source) do
[
'def some_method',
' foo = 1',
' foo += 1',
' foo',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a variable is reassigned ' \
'with logical operator assignment and referenced' do
let(:source) do
[
'def some_method',
' foo = do_something_returns_object_or_nil',
' foo ||= 1',
' foo',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a variable is reassigned with binary operator ' \
'assignment while assigning to itself in rhs ' \
'then referenced' do
let(:source) do
[
'def some_method',
' foo = 1',
' foo += foo = 2',
' foo',
'end'
]
end
it 'registers an offense for the assignment in rhs' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(3)
expect(cop.highlights).to eq(['foo'])
end
end
context 'when a variable is assigned first with ||= and referenced' do
let(:source) do
[
'def some_method',
' foo ||= 1',
' foo',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a variable is assigned with ||= ' \
'at the last expression of the scope' do
let(:source) do
[
'def some_method',
' foo = do_something_returns_object_or_nil',
' foo ||= 1',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(
'Useless assignment to variable - `foo`. Use `||` instead of `||=`.'
)
expect(cop.offenses.first.line).to eq(3)
expect(cop.highlights).to eq(['foo'])
end
end
context 'when a variable is assigned with ||= ' \
'before the last expression of the scope' do
let(:source) do
[
'def some_method',
' foo = do_something_returns_object_or_nil',
' foo ||= 1',
' some_return_value',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(3)
expect(cop.highlights).to eq(['foo'])
end
end
context 'when a variable is assigned with multiple assignment ' \
'and unreferenced' do
let(:source) do
[
'def some_method',
' foo, bar = do_something',
' puts foo',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(
'Useless assignment to variable - `bar`. ' \
'Use `_` or `_bar` as a variable name ' \
"to indicate that it won't be used."
)
expect(cop.offenses.first.line).to eq(2)
expect(cop.highlights).to eq(['bar'])
end
include_examples 'mimics MRI 2.1'
end
context 'when a variable is reassigned with multiple assignment ' \
'while referencing itself in rhs and referenced' do
let(:source) do
[
'def some_method',
' foo = 1',
' foo, bar = do_something(foo)',
' puts foo, bar',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a variable is assigned in loop body ' \
'and referenced in post while condition' do
let(:source) do
[
'begin',
' a = (a || 0) + 1',
' puts a',
'end while a <= 2'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a variable is assigned in loop body ' \
'and referenced in post until condition' do
let(:source) do
[
'begin',
' a = (a || 0) + 1',
' puts a',
'end until a > 2'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a variable is assigned ' \
'in main body of begin with rescue but unreferenced' do
let(:source) do
[
'begin',
' do_something',
' foo = true',
'rescue',
' do_anything',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(3)
expect(cop.highlights).to eq(['foo'])
end
include_examples 'mimics MRI 2.1'
end
context 'when a variable is assigned in main body of begin, rescue ' \
'and else then referenced after the begin' do
let(:source) do
[
'begin',
' do_something',
' foo = :in_begin',
'rescue FirstError',
' foo = :in_first_rescue',
'rescue SecondError',
' foo = :in_second_rescue',
'else',
' foo = :in_else',
'end',
'',
'puts foo'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a variable is reassigned multiple times ' \
'in main body of begin then referenced after the begin' do
let(:source) do
[
'begin',
' status = :initial',
' connect_sometimes_fails!',
' status = :connected',
' fetch_sometimes_fails!',
' status = :fetched',
'rescue',
' do_something',
'end',
'',
'puts status'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a variable is reassigned multiple times ' \
'in main body of begin then referenced in rescue' do
let(:source) do
[
'begin',
' status = :initial',
' connect_sometimes_fails!',
' status = :connected',
' fetch_sometimes_fails!',
' status = :fetched',
'rescue',
' puts status',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a variable is reassigned multiple times ' \
'in main body of begin then referenced in ensure' do
let(:source) do
[
'begin',
' status = :initial',
' connect_sometimes_fails!',
' status = :connected',
' fetch_sometimes_fails!',
' status = :fetched',
'ensure',
' puts status',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a variable is reassigned multiple times in rescue ' \
'and referenced after the begin' do
let(:source) do
[
'foo = false',
'',
'begin',
' do_something',
'rescue',
' foo = true',
' foo = true',
'end',
'',
'puts foo'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(6)
expect(cop.highlights).to eq(['foo'])
end
end
context 'when a variable is reassigned multiple times ' \
'in rescue with ensure then referenced after the begin' do
let(:source) do
[
'foo = false',
'',
'begin',
' do_something',
'rescue',
' foo = true',
' foo = true',
'ensure',
' do_anything',
'end',
'',
'puts foo'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(6)
expect(cop.highlights).to eq(['foo'])
end
end
context 'when a variable is reassigned multiple times ' \
'in ensure with rescue then referenced after the begin' do
let(:source) do
[
'begin',
' do_something',
'rescue',
' do_anything',
'ensure',
' foo = true',
' foo = true',
'end',
'',
'puts foo'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(6)
expect(cop.highlights).to eq(['foo'])
end
end
context 'when a variable is assigned at the end of rescue ' \
'and would be referenced with retry' do
let(:source) do
[
'retried = false',
'',
'begin',
' do_something',
'rescue',
' fail if retried',
' retried = true',
' retry',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a variable is assigned with operator assignment ' \
'in rescue and would be referenced with retry' do
let(:source) do
[
'retry_count = 0',
'',
'begin',
' do_something',
'rescue',
' fail if (retry_count += 1) > 3',
' retry',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a variable is assigned ' \
'in main body of begin, rescue and else ' \
'and reassigned in ensure then referenced after the begin' do
let(:source) do
[
'begin',
' do_something',
' foo = :in_begin',
'rescue FirstError',
' foo = :in_first_rescue',
'rescue SecondError',
' foo = :in_second_rescue',
'else',
' foo = :in_else',
'ensure',
' foo = :in_ensure',
'end',
'',
'puts foo'
]
end
it 'registers offenses for each assignment before ensure' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(4)
expect(cop.offenses[0].line).to eq(3)
expect(cop.offenses[1].line).to eq(5)
expect(cop.offenses[2].line).to eq(7)
expect(cop.offenses[3].line).to eq(9)
end
end
context 'when a rescued error variable is wrongly tried to be referenced ' \
'in another rescue body' do
let(:source) do
[
'begin',
' do_something',
'rescue FirstError => error',
'rescue SecondError',
' p error # => nil',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `error`.')
expect(cop.offenses.first.line).to eq(3)
expect(cop.highlights).to eq(['error'])
end
end
context 'when a method argument is reassigned ' \
'and zero arity super is called' do
let(:source) do
[
'def some_method(foo)',
' foo = 1',
' super',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a local variable is unreferenced ' \
'and zero arity super is called' do
let(:source) do
[
'def some_method(bar)',
' foo = 1',
' super',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(2)
expect(cop.highlights).to eq(['foo'])
end
include_examples 'mimics MRI 2.1'
end
context 'when a method argument is reassigned ' \
'but not passed to super' do
let(:source) do
[
'def some_method(foo, bar)',
' foo = 1',
' super(bar)',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(2)
expect(cop.highlights).to eq(['foo'])
end
end
context 'when a named capture is unreferenced in top level' do
let(:source) do
"/(?\w+)/ =~ 'FOO'"
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(1)
end
include_examples 'mimics MRI 2.1'
end
context 'when a named capture is unreferenced ' \
'in other than top level' do
let(:source) do
[
'def some_method',
" /(?\\w+)/ =~ 'FOO'",
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(2)
expect(cop.highlights).to eq(['/(?\w+)/'])
end
# MRI 2.0 accepts this case, but I have no idea why it does so
# and there's no convincing reason to conform to this behavior,
# so RuboCop does not mimic MRI in this case.
end
context 'when a named capture is referenced' do
let(:source) do
[
'def some_method',
" /(?\w+)(?\s+)/ =~ 'FOO'",
' puts foo',
' puts bar',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a variable is referenced ' \
'in rhs of named capture expression' do
let(:source) do
[
'def some_method',
" foo = 'some string'",
' /(?\w+)/ =~ foo',
' puts foo',
'end'
]
end
include_examples 'accepts'
end
context 'when a variable is assigned in begin ' \
'and referenced outside' do
let(:source) do
[
'def some_method',
' begin',
' foo = 1',
' end',
' puts foo',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a variable is shadowed by a block argument ' \
'and unreferenced' do
let(:source) do
[
'def some_method',
' foo = 1',
' 1.times do |foo|',
' puts foo',
' end',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(2)
expect(cop.highlights).to eq(['foo'])
end
include_examples 'mimics MRI 2.1', 'unused variable'
end
context 'when a variable is not used and the name starts with _' do
let(:source) do
[
'def some_method',
' _foo = 1',
' bar = 2',
' puts bar',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a method argument is not used' do
let(:source) do
[
'def some_method(arg)',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when an optional method argument is not used' do
let(:source) do
[
'def some_method(arg = nil)',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a block method argument is not used' do
let(:source) do
[
'def some_method(&block)',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a splat method argument is not used' do
let(:source) do
[
'def some_method(*args)',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when a optional keyword method argument is not used' do
let(:source) do
[
'def some_method(name: value)',
'end'
]
end
include_examples 'accepts' unless RUBY_VERSION < '2.0'
include_examples 'mimics MRI 2.1'
end
context 'when a keyword splat method argument is used' do
let(:source) do
[
'def some_method(name: value, **rest_keywords)',
' p rest_keywords',
'end'
]
end
include_examples 'accepts' unless RUBY_VERSION < '2.0'
include_examples 'mimics MRI 2.1'
end
context 'when a keyword splat method argument is not used' do
let(:source) do
[
'def some_method(name: value, **rest_keywords)',
'end'
]
end
include_examples 'accepts' unless RUBY_VERSION < '2.0'
include_examples 'mimics MRI 2.1'
end
context 'when an anonymous keyword splat method argument is defined' do
let(:source) do
[
'def some_method(name: value, **)',
'end'
]
end
include_examples 'accepts' unless RUBY_VERSION < '2.0'
include_examples 'mimics MRI 2.1'
end
context 'when a block argument is not used' do
let(:source) do
[
'1.times do |i|',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'when there is only one AST node and it is unused variable' do
let(:source) do
'foo = 1'
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['foo'])
end
include_examples 'mimics MRI 2.1'
end
context 'when a variable is assigned ' \
'while being passed to a method taking block' do
context 'and the variable is used' do
let(:source) do
[
'some_method(foo = 1) do',
'end',
'puts foo'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
context 'and the variable is not used' do
let(:source) do
[
'some_method(foo = 1) do',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `foo`.')
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['foo'])
end
include_examples 'mimics MRI 2.1'
end
end
context 'when a variable is assigned ' \
'and passed to a method followed by method taking block' do
let(:source) do
[
"pattern = '*.rb'",
'Dir.glob(pattern).map do |path|',
'end'
]
end
include_examples 'accepts'
include_examples 'mimics MRI 2.1'
end
# regression test, from problem in Locatable
context 'when a variable is assigned in 2 identical if branches' do
let(:source) do
['def foo',
' if bar',
' foo = 1',
' else',
' foo = 1',
' end',
' foo.bar.baz',
'end']
end
it "doesn't think 1 of the 2 assignments is useless" do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
describe 'similar name suggestion' do
context "when there's a similar variable-like method invocation" do
let(:source) do
[
'def some_method',
' enviromnent = {}',
' another_symbol',
' puts environment',
'end'
]
end
it 'suggests the method name' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(
'Useless assignment to variable - `enviromnent`. ' \
'Did you mean `environment`?'
)
end
end
context "when there's a similar variable" do
let(:source) do
[
'def some_method',
' environment = nil',
' another_symbol',
' enviromnent = {}',
' puts environment',
'end'
]
end
it 'suggests the variable name' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(
'Useless assignment to variable - `enviromnent`. ' \
'Did you mean `environment`?'
)
end
end
context 'when there are only less similar names' do
let(:source) do
[
'def some_method',
' enviromnent = {}',
' another_symbol',
' puts envelope',
'end'
]
end
it 'does not suggest any name' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `enviromnent`.')
end
end
context "when there's a similar method invocation with explicit receiver" do
let(:source) do
[
'def some_method',
' enviromnent = {}',
' another_symbol',
' puts self.environment',
'end'
]
end
it 'does not suggest any name' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `enviromnent`.')
end
end
context "when there's a similar method invocation with arguments" do
let(:source) do
[
'def some_method',
' enviromnent = {}',
' another_symbol',
' puts environment(1)',
'end'
]
end
it 'does not suggest any name' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `enviromnent`.')
end
end
context "when there's a similar name but it's in inner scope" do
let(:source) do
[
'class SomeClass',
' enviromnent = {}',
'',
' def some_method(environment)',
' puts environment',
' end',
'end'
]
end
it 'does not suggest any name' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Useless assignment to variable - `enviromnent`.')
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/useless_comparison_spec.rb 0000664 0000000 0000000 00000001356 13070542236 0026550 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::UselessComparison do
subject(:cop) { described_class.new }
described_class::OPS.each do |op|
it "registers an offense for a simple comparison with #{op}" do
inspect_source(cop,
["5 #{op} 5",
"a #{op} a"])
expect(cop.offenses.size).to eq(2)
end
it "registers an offense for a complex comparison with #{op}" do
inspect_source(cop,
["5 + 10 * 30 #{op} 5 + 10 * 30",
"a.top(x) #{op} a.top(x)"])
expect(cop.offenses.size).to eq(2)
end
end
it 'works with lambda.()' do
inspect_source(cop, 'a.(x) > a.(x)')
expect(cop.offenses.size).to eq(1)
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/useless_else_without_rescue_spec.rb 0000664 0000000 0000000 00000001660 13070542236 0030455 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::UselessElseWithoutRescue do
subject(:cop) { described_class.new }
before do
inspect_source(cop, source)
end
context 'with `else` without `rescue`' do
let(:source) do
[
'begin',
' do_something',
'else',
' handle_unknown_errors',
'end'
]
end
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('`else` without `rescue` is useless.')
expect(cop.highlights).to eq(['else'])
end
end
context 'with `else` with `rescue`' do
let(:source) do
[
'begin',
' do_something',
'rescue ArgumentError',
' handle_argument_error',
'else',
' handle_unknown_errors',
'end'
]
end
it 'accepts' do
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/useless_setter_call_spec.rb 0000664 0000000 0000000 00000014350 13070542236 0026675 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::UselessSetterCall do
subject(:cop) { described_class.new }
context 'with method ending with setter call on local object' do
it 'registers an offense' do
inspect_source(cop,
['def test',
' top = Top.new',
' top.attr = 5',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Useless setter call to local variable `top`.'])
end
end
context 'with singleton method ending with setter call on local object' do
it 'registers an offense' do
inspect_source(cop,
['def Top.test',
' top = Top.new',
' top.attr = 5',
'end'])
expect(cop.offenses.size).to eq(1)
end
end
context 'with method ending with square bracket setter on local object' do
it 'registers an offense' do
inspect_source(cop,
['def test',
' top = Top.new',
' top[:attr] = 5',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Useless setter call to local variable `top`.'])
end
end
context 'with method ending with ivar assignment' do
it 'accepts' do
inspect_source(cop,
['def test',
' something',
' @top = 5',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with method ending with setter call on ivar' do
it 'accepts' do
inspect_source(cop,
['def test',
' something',
' @top.attr = 5',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with method ending with setter call on argument' do
it 'accepts' do
inspect_source(cop,
['def test(some_arg)',
' unrelated_local_variable = Top.new',
' some_arg.attr = 5',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'when a lvar contains an object passed as argument ' \
'at the end of the method' do
it 'accepts the setter call on the lvar' do
inspect_source(cop,
['def test(some_arg)',
' @some_ivar = some_arg',
' @some_ivar.do_something',
' some_lvar = @some_ivar',
' some_lvar.do_something',
' some_lvar.attr = 5',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'when a lvar contains an object passed as argument ' \
'by multiple-assignment at the end of the method' do
it 'accepts the setter call on the lvar' do
inspect_source(cop,
['def test(some_arg)',
' _first, some_lvar, _third = 1, some_arg, 3',
' some_lvar.attr = 5',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'when a lvar does not contain any object passed as argument ' \
'with multiple-assignment at the end of the method' do
it 'registers an offense' do
inspect_source(cop,
['def test(some_arg)',
' _first, some_lvar, _third = do_something',
' some_lvar.attr = 5',
'end'])
expect(cop.offenses.size).to eq(1)
end
end
context 'when a lvar possibly contains an object passed as argument ' \
'by logical-operator-assignment at the end of the method' do
it 'accepts the setter call on the lvar' do
inspect_source(cop,
['def test(some_arg)',
' some_lvar = nil',
' some_lvar ||= some_arg',
' some_lvar.attr = 5',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'when a lvar does not contain any object passed as argument ' \
'by binary-operator-assignment at the end of the method' do
it 'registers an offense' do
inspect_source(cop,
['def test(some_arg)',
' some_lvar = some_arg',
' some_lvar += some_arg',
' some_lvar.attr = 5',
'end'])
expect(cop.offenses.size).to eq(1)
end
end
context 'when a lvar declared as an argument ' \
'is no longer the passed object at the end of the method' do
it 'registers an offense for the setter call on the lvar' do
inspect_source(cop,
['def test(some_arg)',
' some_arg = Top.new',
' some_arg.attr = 5',
'end'])
expect(cop.offenses.size).to eq(1)
end
end
context 'when a lvar contains a local object instantiated with literal' do
it 'registers an offense for the setter call on the lvar' do
inspect_source(cop,
['def test',
' some_arg = {}',
' some_arg[:attr] = 1',
'end'])
expect(cop.offenses.size).to eq(1)
end
end
context 'when a lvar contains a non-local object returned by a method' do
it 'accepts' do
inspect_source(cop,
['def test',
' some_lvar = Foo.shared_object',
' some_lvar[:attr] = 1',
'end'])
expect(cop.offenses).to be_empty
end
end
it 'is not confused by operators ending with =' do
inspect_source(cop,
['def test',
' top.attr == 5',
'end'])
expect(cop.offenses).to be_empty
end
it 'handles exception assignments without exploding' do
inspect_source(cop,
['def foo(bar)',
' begin',
' rescue StandardError => _',
' end',
' bar[:baz] = true',
'end'])
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/lint/void_spec.rb 0000664 0000000 0000000 00000004630 13070542236 0023572 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Lint::Void do
subject(:cop) { described_class.new }
described_class::OPS.each do |op|
it "registers an offense for void op #{op} if not on last line" do
inspect_source(cop,
["a #{op} b",
"a #{op} b",
"a #{op} b"])
expect(cop.offenses.size).to eq(2)
end
end
described_class::OPS.each do |op|
it "accepts void op #{op} if on last line" do
inspect_source(cop,
['something',
"a #{op} b"])
expect(cop.offenses).to be_empty
end
end
described_class::OPS.each do |op|
it "accepts void op #{op} by itself without a begin block" do
inspect_source(cop, "a #{op} b")
expect(cop.offenses).to be_empty
end
end
%w[var @var @@var VAR].each do |var|
it "registers an offense for void var #{var} if not on last line" do
inspect_source(cop,
["#{var} = 5",
var,
'top'])
expect(cop.offenses.size).to eq(1)
end
end
%w(1 2.0 :test /test/ [1] {}).each do |lit|
it "registers an offense for void lit #{lit} if not on last line" do
inspect_source(cop,
[lit,
'top'])
expect(cop.offenses.size).to eq(1)
end
end
it 'registers an offense for void `self` if not on last line' do
inspect_source(cop, 'self; top')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for void `defined?` if not on last line' do
inspect_source(cop,
['defined?(x)',
'top'])
expect(cop.offenses.size).to eq(1)
end
it 'handles explicit begin blocks' do
inspect_source(cop,
['begin',
' 1',
' 2',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'accepts short call syntax' do
inspect_source(cop,
['lambda.(a)',
'top'])
expect(cop.offenses).to be_empty
end
it 'accepts backtick commands' do
inspect_source(cop,
['`touch x`',
'nil'])
expect(cop.offenses).to be_empty
end
it 'accepts percent-x commands' do
inspect_source(cop,
['%x(touch x)',
'nil'])
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/message_annotator_spec.rb 0000664 0000000 0000000 00000010405 13070542236 0025371 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::MessageAnnotator do
let(:options) { {} }
let(:config) { RuboCop::Config.new({}) }
let(:annotator) { described_class.new(config, config['Cop/Cop'], options) }
describe '#annotate' do
subject(:annotate) do
annotator.annotate('message', 'Cop/Cop')
end
context 'with default options' do
it 'returns the message' do
expect(annotate).to eq('message')
end
end
context 'with options on' do
let(:options) do
{
extra_details: true,
display_cop_names: true,
display_style_guide: true
}
end
let(:config) do
RuboCop::Config.new(
'Cop/Cop' => {
'Details' => 'my cop details',
'StyleGuide' => 'http://example.org/styleguide'
}
)
end
it 'returns an annotated message' do
expect(annotate).to eq(
'Cop/Cop: message my cop details (http://example.org/styleguide)'
)
end
end
end
describe 'with style guide url' do
subject(:annotate) do
annotator.annotate('', 'Cop/Cop')
end
let(:options) do
{
display_style_guide: true
}
end
context 'when StyleGuide is not set in the config' do
let(:config) { RuboCop::Config.new({}) }
it 'does not add style guide url' do
expect(annotate).to eq('')
end
end
context 'when StyleGuide is set in the config' do
let(:config) do
RuboCop::Config.new(
'Cop/Cop' => { 'StyleGuide' => 'http://example.org/styleguide' }
)
end
it 'adds style guide url' do
expect(annotate).to include('http://example.org/styleguide')
end
end
context 'when a base URL is specified' do
let(:config) do
RuboCop::Config.new(
'AllCops' => {
'StyleGuideBaseURL' => 'http://example.org/styleguide'
}
)
end
it 'does not specify a URL if a cop does not have one' do
config['Cop/Cop'] = { 'StyleGuide' => nil }
expect(annotate).to eq('')
end
it 'combines correctly with a target-based setting' do
config['Cop/Cop'] = { 'StyleGuide' => '#target_based_url' }
expect(annotate).to include('http://example.org/styleguide#target_based_url')
end
it 'can use a path-based setting' do
config['Cop/Cop'] = { 'StyleGuide' => 'cop/path/rule#target_based_url' }
expect(annotate).to include('http://example.org/cop/path/rule#target_based_url')
end
it 'can accept relative paths if base has a full path' do
config['AllCops'] = {
'StyleGuideBaseURL' => 'http://github.com/bbatsov/ruby-style-guide/'
}
config['Cop/Cop'] = {
'StyleGuide' => '../rails-style-guide#target_based_url'
}
expect(annotate).to include('http://github.com/bbatsov/rails-style-guide#target_based_url')
end
it 'allows absolute URLs in the cop config' do
config['Cop/Cop'] = { 'StyleGuide' => 'http://other.org#absolute_url' }
expect(annotate).to include('http://other.org#absolute_url')
end
end
end
describe '#urls' do
let(:urls) { annotator.urls }
let(:config) do
RuboCop::Config.new(
'AllCops' => {
'StyleGuideBaseURL' => 'http://example.org/styleguide'
}
)
end
it 'returns an empty array without StyleGuide URL' do
expect(urls).to be_empty
end
it 'returns style guide url when it is specified' do
config['Cop/Cop'] = { 'StyleGuide' => '#target_based_url' }
expect(urls).to eq(%w[http://example.org/styleguide#target_based_url])
end
it 'returns reference url when it is specified' do
config['Cop/Cop'] = {
'Reference' => 'https://example.com/some_style_guide'
}
expect(urls).to eq(%w[https://example.com/some_style_guide])
end
it 'returns style guide and reference url when they are specified' do
config['Cop/Cop'] = {
'StyleGuide' => '#target_based_url',
'Reference' => 'https://example.com/some_style_guide'
}
expect(urls).to eq(%w[http://example.org/styleguide#target_based_url
https://example.com/some_style_guide])
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/metrics/ 0000775 0000000 0000000 00000000000 13070542236 0021767 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/metrics/abc_size_spec.rb 0000664 0000000 0000000 00000010205 13070542236 0025103 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Metrics::AbcSize, :config do
subject(:cop) { described_class.new(config) }
context 'when Max is 0' do
let(:cop_config) { { 'Max' => 0 } }
it 'accepts an empty method' do
inspect_source(cop, ['def method_name',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for an if modifier' do
inspect_source(cop, ['def method_name',
' call_foo if some_condition', # 0 + 2*2 + 1*1
'end'])
expect(cop.messages)
.to eq(['Assignment Branch Condition size for method_name is too ' \
'high. [2.24/0]'])
expect(cop.highlights).to eq(['def'])
expect(cop.config_to_allow_offenses).to eq('Max' => 3)
end
it 'registers an offense for an assignment of a local variable' do
inspect_source(cop, ['def method_name',
' x = 1',
'end'])
expect(cop.messages)
.to eq(['Assignment Branch Condition size for method_name is too ' \
'high. [1/0]'])
expect(cop.config_to_allow_offenses).to eq('Max' => 1)
end
it 'registers an offense for an assignment of an element' do
inspect_source(cop, ['def method_name',
' x[0] = 1',
'end'])
expect(cop.messages)
.to eq(['Assignment Branch Condition size for method_name is too ' \
'high. [1.41/0]'])
expect(cop.config_to_allow_offenses).to eq('Max' => 2)
end
it 'registers an offense for complex content including A, B, and C ' \
'scores' do
inspect_source(cop,
['def method_name',
' my_options = Hash.new if 1 == 1 || 2 == 2', # 1, 3, 2
' my_options.each do |key, value|', # 0, 1, 0
' p key', # 0, 1, 0
' p value', # 0, 1, 0
' end',
'end'])
expect(cop.messages)
.to eq(['Assignment Branch Condition size for method_name is too ' \
'high. [6.4/0]']) # sqrt(1*1 + 6*6 + 2*2) => 6.4
end
context 'target_ruby_version >= 2.3', :ruby23 do
it 'treats safe navigation method calls like regular method calls' do
inspect_source(cop,
['def method_name',
' object&.do_something',
'end'])
expect(cop.messages)
.to eq(['Assignment Branch Condition size for method_name is too ' \
'high. [2/0]']) # sqrt(0 + 2*2 + 0) => 2
end
end
end
context 'when Max is 2' do
let(:cop_config) { { 'Max' => 2 } }
it 'accepts two assignments' do
inspect_source(cop, ['def method_name',
' x = 1',
' y = 2',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'when Max is 1.8' do
let(:cop_config) { { 'Max' => 1.8 } }
it 'accepts a total score of 1.7' do
inspect_source(cop, ['def method_name',
' y = 1 if y == 1',
'end'])
expect(cop.offenses).to be_empty
end
end
{
1.3 => '3.74/1.3', # no more than 2 decimals reported
10.3 => '37.42/10.3',
100.321 => '374.2/100.3', # 4 significant digits, so only 1 decimal here
1000.3 => '3742/1000'
}.each do |max, presentation|
context "when Max is #{max}" do
let(:cop_config) { { 'Max' => max } }
it "reports size and max as #{presentation}" do
# Build an amount of code large enough to register an offense.
code = [' x = Hash.new if 1 == 1 || 2 == 2'] * max
inspect_source(cop, ['def method_name',
*code,
'end'])
expect(cop.messages)
.to eq(['Assignment Branch Condition size for method_name is too ' \
"high. [#{presentation}]"])
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/metrics/block_length_spec.rb 0000664 0000000 0000000 00000010262 13070542236 0025762 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Metrics::BlockLength, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'Max' => 2, 'CountComments' => false } }
it 'rejects a block with more than 5 lines' do
inspect_source(cop, ['something do',
' a = 1',
' a = 2',
' a = 3',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.map(&:line).sort).to eq([1])
expect(cop.config_to_allow_offenses).to eq('Max' => 3)
expect(cop.messages.first).to eq('Block has too many lines. [3/2]')
end
it 'reports the correct beginning and end lines' do
inspect_source(cop, ['something do',
' a = 1',
' a = 2',
' a = 3',
'end'])
offense = cop.offenses.first
expect(offense.location.first_line).to eq(1)
expect(offense.location.last_line).to eq(5)
end
it 'accepts a block with less than 3 lines' do
inspect_source(cop, ['something do',
' a = 1',
' a = 2',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not count blank lines' do
inspect_source(cop, ['something do',
' a = 1',
'',
'',
' a = 4',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts a block with multiline receiver and less than 3 lines of body' do
inspect_source(cop, ['[',
' :a,',
' :b,',
' :c,',
'].each do',
' a = 1',
' a = 2',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts empty blocks' do
inspect_source(cop, ['something do',
'end'])
expect(cop.offenses).to be_empty
end
it 'rejects brace blocks too' do
inspect_source(cop, ['something {',
' a = 1',
' a = 2',
' a = 3',
'}'])
expect(cop.offenses.size).to eq(1)
end
it 'properly counts nested blocks' do
inspect_source(cop, ['something do',
' something do',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' end',
'end'])
expect(cop.offenses.size).to eq(2)
expect(cop.offenses.map(&:line).sort).to eq([1, 2])
end
it 'does not count commented lines by default' do
inspect_source(cop, ['something do',
' a = 1',
' #a = 2',
' #a = 3',
' a = 4',
'end'])
expect(cop.offenses).to be_empty
end
context 'when CountComments is enabled' do
before { cop_config['CountComments'] = true }
it 'also counts commented lines' do
inspect_source(cop, ['something do',
' a = 1',
' #a = 2',
' a = 3',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.map(&:line).sort).to eq([1])
end
end
context 'when foo method is excluded is enabled' do
before { cop_config['ExcludedMethods'] = ['foo'] }
it 'still rejects other methods with long blocks' do
inspect_source(cop, ['something do',
' a = 1',
' a = 2',
' a = 3',
'end'])
expect(cop.offenses).not_to be_empty
end
it 'accepts the foo method with a long block' do
inspect_source(cop, ['foo do',
' a = 1',
' a = 2',
' a = 3',
'end'])
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/metrics/block_nesting_spec.rb 0000664 0000000 0000000 00000012567 13070542236 0026162 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Metrics::BlockNesting, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'Max' => 2 } }
shared_examples 'too deep' do |source, lines, max_to_allow = 3|
it "registers #{lines.length} offense(s)" do
inspect_source(cop, source)
expect(cop.offenses.map(&:line)).to eq(lines)
expect(cop.messages).to eq(
['Avoid more than 2 levels of block nesting.'] * lines.length
)
end
it 'sets `Max` value correctly' do
inspect_source(cop, source)
expect(cop.config_to_allow_offenses['Max']).to eq(max_to_allow)
end
end
it 'accepts `Max` levels of nesting' do
inspect_source(cop, ['if a',
' if b',
' puts b',
' end',
'end'])
expect(cop.offenses).to be_empty
end
context '`Max + 1` levels of `if` nesting' do
source = ['if a',
' if b',
' if c',
' puts c',
' end',
' end',
'end']
it_behaves_like 'too deep', source, [3]
end
context '`Max + 2` levels of `if` nesting' do
source = ['if a',
' if b',
' if c',
' if d',
' puts d',
' end',
' end',
' end',
'end']
it_behaves_like 'too deep', source, [3], 4
end
context 'Multiple nested `ifs` at same level' do
source = ['if a',
' if b',
' if c',
' puts c',
' end',
' end',
' if d',
' if e',
' puts e',
' end',
' end',
'end']
it_behaves_like 'too deep', source, [3, 8]
end
context 'nested `case`' do
source = ['if a',
' if b',
' case c',
' when C',
' puts C',
' end',
' end',
'end']
it_behaves_like 'too deep', source, [3]
end
context 'nested `while`' do
source = ['if a',
' if b',
' while c',
' puts c',
' end',
' end',
'end']
it_behaves_like 'too deep', source, [3]
end
context 'nested modifier `while`' do
source = ['if a',
' if b',
' begin',
' puts c',
' end while c',
' end',
'end']
it_behaves_like 'too deep', source, [3]
end
context 'nested `until`' do
source = ['if a',
' if b',
' until c',
' puts c',
' end',
' end',
'end']
it_behaves_like 'too deep', source, [3]
end
context 'nested modifier `until`' do
source = ['if a',
' if b',
' begin',
' puts c',
' end until c',
' end',
'end']
it_behaves_like 'too deep', source, [3]
end
context 'nested `for`' do
source = ['if a',
' if b',
' for c in [1,2] do',
' puts c',
' end',
' end',
'end']
it_behaves_like 'too deep', source, [3]
end
context 'nested `rescue`' do
source = ['if a',
' if b',
' begin',
' puts c',
' rescue',
' puts x',
' end',
' end',
'end']
it_behaves_like 'too deep', source, [5]
end
it 'accepts if/elsif' do
inspect_source(cop, ['if a',
'elsif b',
'elsif c',
'elsif d',
'end'])
expect(cop.offenses).to be_empty
end
context 'when CountBlocks is false' do
let(:cop_config) { { 'Max' => 2, 'CountBlocks' => false } }
it 'accepts nested multiline blocks' do
inspect_source(cop, ['if a',
' if b',
' [1, 2].each do |c|',
' puts c',
' end',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts nested inline blocks' do
inspect_source(cop, ['if a',
' if b',
' [1, 2].each { |c| puts c }',
' end',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'when CountBlocks is true' do
let(:cop_config) { { 'Max' => 2, 'CountBlocks' => true } }
context 'nested multiline block' do
source = ['if a',
' if b',
' [1, 2].each do |c|',
' puts c',
' end',
' end',
'end']
it_behaves_like 'too deep', source, [3]
end
context 'nested inline block' do
source = ['if a',
' if b',
' [1, 2].each { |c| puts c }',
' end',
'end']
it_behaves_like 'too deep', source, [3]
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/metrics/class_length_spec.rb 0000664 0000000 0000000 00000011403 13070542236 0025773 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Metrics::ClassLength, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'Max' => 5, 'CountComments' => false } }
it 'rejects a class with more than 5 lines' do
inspect_source(cop, ['class Test',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' a = 6',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Class has too many lines. [6/5]'])
expect(cop.config_to_allow_offenses).to eq('Max' => 6)
end
it 'reports the correct beginning and end lines' do
inspect_source(cop, ['class Test',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' a = 6',
'end'])
offense = cop.offenses.first
expect(offense.location.first_line).to eq(1)
expect(offense.location.last_line).to eq(8)
end
it 'accepts a class with 5 lines' do
inspect_source(cop, ['class Test',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts a class with less than 5 lines' do
inspect_source(cop, ['class Test',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not count blank lines' do
inspect_source(cop, ['class Test',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
'',
'',
' a = 7',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts empty classes' do
inspect_source(cop, ['class Test',
'end'])
expect(cop.offenses).to be_empty
end
context 'when a class has inner classes' do
it 'does not count lines of inner classes' do
inspect_source(cop, ['class NamespaceClass',
' class TestOne',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' end',
' class TestTwo',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' end',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
'end'])
expect(cop.offenses).to be_empty
end
it 'rejects a class with 6 lines that belong to the class directly' do
inspect_source(cop, ['class NamespaceClass',
' class TestOne',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' end',
' class TestTwo',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' end',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' a = 6',
'end'])
expect(cop.offenses.size).to eq(1)
end
end
context 'when CountComments is enabled' do
before { cop_config['CountComments'] = true }
it 'also counts commented lines' do
inspect_source(cop, ['class Test',
' a = 1',
' #a = 2',
' a = 3',
' #a = 4',
' a = 5',
' a = 6',
'end'])
expect(cop.offenses.size).to eq(1)
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/metrics/cyclomatic_complexity_spec.rb 0000664 0000000 0000000 00000016713 13070542236 0027742 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Metrics::CyclomaticComplexity, :config do
subject(:cop) { described_class.new(config) }
context 'when Max is 1' do
let(:cop_config) { { 'Max' => 1 } }
it 'accepts a method with no decision points' do
inspect_source(cop, ['def method_name',
' call_foo',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts complex code outside of methods' do
inspect_source(cop,
['def method_name',
' call_foo',
'end',
'',
'if first_condition then',
' call_foo if second_condition && third_condition',
' call_bar if fourth_condition || fifth_condition',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for an if modifier' do
inspect_source(cop, ['def self.method_name',
' call_foo if some_condition',
'end'])
expect(cop.messages)
.to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
expect(cop.highlights).to eq(['def'])
expect(cop.config_to_allow_offenses).to eq('Max' => 2)
end
it 'registers an offense for an unless modifier' do
inspect_source(cop, ['def method_name',
' call_foo unless some_condition',
'end'])
expect(cop.messages)
.to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
end
it 'registers an offense for an elsif block' do
inspect_source(cop, ['def method_name',
' if first_condition then',
' call_foo',
' elsif second_condition then',
' call_bar',
' else',
' call_bam',
' end',
'end'])
expect(cop.messages)
.to eq(['Cyclomatic complexity for method_name is too high. [3/1]'])
end
it 'registers an offense for a ternary operator' do
inspect_source(cop, ['def method_name',
' value = some_condition ? 1 : 2',
'end'])
expect(cop.messages)
.to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
end
it 'registers an offense for a while block' do
inspect_source(cop, ['def method_name',
' while some_condition do',
' call_foo',
' end',
'end'])
expect(cop.messages)
.to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
end
it 'registers an offense for an until block' do
inspect_source(cop, ['def method_name',
' until some_condition do',
' call_foo',
' end',
'end'])
expect(cop.messages)
.to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
end
it 'registers an offense for a for block' do
inspect_source(cop, ['def method_name',
' for i in 1..2 do',
' call_method',
' end',
'end'])
expect(cop.messages)
.to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
end
it 'registers an offense for a rescue block' do
inspect_source(cop, ['def method_name',
' begin',
' call_foo',
' rescue Exception',
' call_bar',
' end',
'end'])
expect(cop.messages)
.to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
end
it 'registers an offense for a case/when block' do
inspect_source(cop, ['def method_name',
' case value',
' when 1',
' call_foo',
' when 2',
' call_bar',
' end',
'end'])
expect(cop.messages)
.to eq(['Cyclomatic complexity for method_name is too high. [3/1]'])
end
it 'registers an offense for &&' do
inspect_source(cop, ['def method_name',
' call_foo && call_bar',
'end'])
expect(cop.messages)
.to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
end
it 'registers an offense for and' do
inspect_source(cop, ['def method_name',
' call_foo and call_bar',
'end'])
expect(cop.messages)
.to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
end
it 'registers an offense for ||' do
inspect_source(cop, ['def method_name',
' call_foo || call_bar',
'end'])
expect(cop.messages)
.to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
end
it 'registers an offense for or' do
inspect_source(cop, ['def method_name',
' call_foo or call_bar',
'end'])
expect(cop.messages)
.to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
end
it 'deals with nested if blocks containing && and ||' do
inspect_source(cop,
['def method_name',
' if first_condition then',
' call_foo if second_condition && third_condition',
' call_bar if fourth_condition || fifth_condition',
' end',
'end'])
expect(cop.messages)
.to eq(['Cyclomatic complexity for method_name is too high. [6/1]'])
end
it 'counts only a single method' do
inspect_source(cop, ['def method_name_1',
' call_foo if some_condition',
'end',
'',
'def method_name_2',
' call_foo if some_condition',
'end'])
expect(cop.messages)
.to eq(['Cyclomatic complexity for method_name_1 is too high. [2/1]',
'Cyclomatic complexity for method_name_2 is too high. [2/1]'])
end
end
context 'when Max is 2' do
let(:cop_config) { { 'Max' => 2 } }
it 'counts stupid nested if and else blocks' do
inspect_source(cop, ['def method_name',
' if first_condition then',
' call_foo',
' else',
' if second_condition then',
' call_bar',
' else',
' call_bam if third_condition',
' end',
' call_baz if fourth_condition',
' end',
'end'])
expect(cop.messages)
.to eq(['Cyclomatic complexity for method_name is too high. [5/2]'])
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/metrics/line_length_spec.rb 0000664 0000000 0000000 00000026767 13070542236 0025640 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Metrics::LineLength, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'Max' => 80, 'IgnoredPatterns' => nil } }
it "registers an offense for a line that's 81 characters wide" do
inspect_source(cop, '#' * 81)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq('Line is too long. [81/80]')
expect(cop.config_to_allow_offenses).to eq('Max' => 81)
end
it 'highlights excessive characters' do
inspect_source(cop, '#' * 80 + 'abc')
expect(cop.highlights).to eq(['abc'])
end
it "accepts a line that's 80 characters wide" do
inspect_source(cop, '#' * 80)
expect(cop.offenses).to be_empty
end
it 'registers an offense for long line before __END__ but not after' do
inspect_source(cop, ['#' * 150,
'__END__',
'#' * 200])
expect(cop.messages).to eq(['Line is too long. [150/80]'])
end
context 'when AllowURI option is enabled' do
let(:cop_config) { { 'Max' => 80, 'AllowURI' => true } }
context 'and all the excessive characters are part of an URL' do
# This code example is allowed by AllowURI feature itself :).
let(:source) { <<-END }
# Some documentation comment...
# See: https://github.com/bbatsov/rubocop/commit/3b48d8bdf5b1c2e05e35061837309890f04ab08c
END
it 'accepts the line' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
context 'and the excessive characters include a complete URL' do
let(:source) { <<-END }
# See: http://google.com/, http://gmail.com/, https://maps.google.com/, http://plus.google.com/
END
it 'registers an offense for the line' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'highlights all the excessive characters' do
inspect_source(cop, source)
expect(cop.highlights).to eq(['http://plus.google.com/'])
end
end
context 'and the excessive characters include part of an URL ' \
'and another word' do
let(:source) { <<-END }
# See: https://github.com/bbatsov/rubocop/commit/3b48d8bdf5b1c2e05e35061837309890f04ab08c and
# http://google.com/
END
it 'registers an offense for the line' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'highlights only the non-URL part' do
inspect_source(cop, source)
expect(cop.highlights).to eq([' and'])
end
end
context 'and an error other than URI::InvalidURIError is raised ' \
'while validating an URI-ish string' do
let(:cop_config) do
{ 'Max' => 80, 'AllowURI' => true, 'URISchemes' => %w[LDAP] }
end
let(:source) { <<-END }
xxxxxxxxxxxxxxxxxxxxxxxxxxxxzxxxxxxxxxxx = LDAP::DEFAULT_GROUP_UNIQUE_MEMBER_LIST_KEY
END
it 'does not crash' do
expect { inspect_source(cop, source) }.not_to raise_error
end
end
context 'and the URL does not have a http(s) scheme' do
let(:source) { <<-END }
xxxxxxxxxxxxxxxxxxxxxxxxxxxxzxxxxxxxxxxx = 'otherprotocol://a.very.long.line.which.violates.LineLength/sadf'
END
it 'rejects the line' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
context 'and the scheme has been configured' do
let(:cop_config) do
{ 'Max' => 80, 'AllowURI' => true, 'URISchemes' => %w[otherprotocol] }
end
it 'accepts the line' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
end
context 'when IgnoredPatterns option is set' do
let(:cop_config) do
{
'Max' => 18,
'IgnoredPatterns' => ['^\s*test\s', /^\s*def\s+test_/]
}
end
let(:source) do
['class ExampleTest < TestCase',
" test 'some really long test description which exceeds length' do",
' end',
' def test_some_other_long_test_description_which_exceeds_length',
' end',
'end']
end
it 'accepts long lines matching a pattern but not other long lines' do
inspect_source(cop, source)
expect(cop.highlights).to eq(['< TestCase'])
end
end
context 'when AllowHeredoc option is enabled' do
let(:cop_config) { { 'Max' => 80, 'AllowHeredoc' => true } }
let(:source) { <<-END }
<<-SQL
SELECT posts.id, posts.title, users.name FROM posts LEFT JOIN users ON posts.user_id = users.id;
SQL
END
it 'accepts long lines in heredocs' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
context 'when the source has no AST' do
let(:source) { '# this results in AST being nil' }
it 'does not crash' do
expect { inspect_source(cop, source) }.not_to raise_error
end
end
context 'and only certain heredoc delimiters are whitelisted' do
let(:cop_config) do
{ 'Max' => 80, 'AllowHeredoc' => %w[SQL OK], 'IgnoredPatterns' => [] }
end
let(:source) { <<-END }
foo(<<-DOC, <<-SQL, <<-FOO)
1st offence: Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
\#{<<-OK}
no offence (whitelisted): Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
OK
2nd offence: Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
DOC
no offence (whitelisted): Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
\#{<<-XXX}
no offence (nested inside whitelisted): Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
XXX
no offence (whitelisted): Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
SQL
3rd offence: Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
\#{<<-SQL}
no offence (whitelisted): Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
SQL
4th offence: Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
FOO
END
it 'rejects long lines in heredocs with not whitelisted delimiters' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(4)
end
end
end
context 'when AllowURI option is disabled' do
let(:cop_config) { { 'Max' => 80, 'AllowURI' => false } }
context 'and all the excessive characters are part of an URL' do
let(:source) { <<-END }
# See: https://github.com/bbatsov/rubocop/commit/3b48d8bdf5b1c2e05e35061837309890f04ab08c
END
it 'registers an offense for the line' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
end
end
context 'when IgnoreCopDirectives is disabled' do
let(:cop_config) { { 'Max' => 80, 'IgnoreCopDirectives' => false } }
context 'and the source is acceptable length' do
let(:acceptable_source) { 'a' * 80 }
context 'with a trailing Rubocop directive' do
let(:cop_directive) { ' # rubcop:disable Metrics/SomeCop' }
let(:source) { acceptable_source + cop_directive }
it 'registers an offense for the line' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'highlights the excess directive' do
inspect_source(cop, source)
expect(cop.highlights).to eq([cop_directive])
end
end
context 'with an inline comment' do
let(:excess_comment) { ' ###' }
let(:source) { acceptable_source + excess_comment }
it 'highlights the excess comment' do
inspect_source(cop, source)
expect(cop.highlights).to eq([excess_comment])
end
end
end
context 'and the source is too long and has a trailing cop directive' do
let(:excess_with_directive) { 'b # rubocop:disable Metrics/AbcSize' }
let(:source) { 'a' * 80 + excess_with_directive }
it 'highlights the excess source and cop directive' do
inspect_source(cop, source)
expect(cop.highlights).to eq([excess_with_directive])
end
end
end
context 'when IgnoreCopDirectives is enabled' do
let(:cop_config) { { 'Max' => 80, 'IgnoreCopDirectives' => true } }
context 'and the Rubocop directive is excessively long' do
let(:source) { <<-END }
# rubocop:disable Metrics/SomeReallyLongMetricNameThatShouldBeMuchShorterAndNeedsANameChange
END
it 'accepts the line' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
context 'and the Rubocop directive causes an excessive line length' do
let(:source) { <<-END }
def method_definition_that_is_just_under_the_line_length_limit(foo, bar) # rubocop:disable Metrics/AbcSize
# complex method
end
END
it 'accepts the line' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
context 'and has explanatory text' do
let(:source) { <<-END }
def method_definition_that_is_just_under_the_line_length_limit(foo) # rubocop:disable Metrics/AbcSize inherently complex!
# complex
end
END
it 'accepts the line' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
context 'and the source is too long' do
let(:source) { 'a' * 80 + 'bcd' + ' # rubocop:enable Style/ClassVars' }
it 'registers an offense for the line' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'highlights only the non-directive part' do
inspect_source(cop, source)
expect(cop.highlights).to eq(['bcd'])
end
context 'and the source contains non-directive # as comment' do
let(:source) { <<-END }
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa # bbbbbbbbbbbbbb # rubocop:enable Style/ClassVars'
END
it 'registers an offense for the line' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'highlights only the non-directive part' do
inspect_source(cop, source)
expect(cop.highlights).to eq(['bbbbbbb'])
end
end
context 'and the source contains non-directive #s as non-comment' do
let(:source) { <<-END }
LARGE_DATA_STRING_PATTERN = %r{\A([A-Za-z0-9\+\/#]*\={0,2})#([A-Za-z0-9\+\/#]*\={0,2})#([A-Za-z0-9\+\/#]*\={0,2})\z} # rubocop:disable LineLength
END
it 'registers an offense for the line' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'highlights only the non-directive part' do
inspect_source(cop, source)
expect(cop.highlights).to eq([']*={0,2})#([A-Za-z0-9+/#]*={0,2})z}'])
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/metrics/method_length_spec.rb 0000664 0000000 0000000 00000013162 13070542236 0026152 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Metrics::MethodLength, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'Max' => 5, 'CountComments' => false } }
it 'rejects a method with more than 5 lines' do
inspect_source(cop, ['def m()',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' a = 6',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.map(&:line).sort).to eq([1])
expect(cop.config_to_allow_offenses).to eq('Max' => 6)
expect(cop.messages.first).to eq('Method has too many lines. [6/5]')
end
it 'reports the correct beginning and end lines' do
inspect_source(cop, ['def m()',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' a = 6',
'end'])
offense = cop.offenses.first
expect(offense.location.first_line).to eq(1)
expect(offense.location.last_line).to eq(8)
end
it 'accepts a method with less than 5 lines' do
inspect_source(cop, ['def m()',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts a method with multiline arguments ' \
'and less than 5 lines of body' do
inspect_source(cop, ['def m(x,',
' y,',
' z)',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not count blank lines' do
inspect_source(cop, ['def m()',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
'',
'',
' a = 7',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts empty methods' do
inspect_source(cop, ['def m()',
'end'])
expect(cop.offenses).to be_empty
end
it 'is not fooled by one-liner methods, syntax #1' do
inspect_source(cop, ['def one_line; 10 end',
'def self.m()',
' a = 1',
' a = 2',
' a = 4',
' a = 5',
' a = 6',
'end'])
expect(cop.offenses).to be_empty
end
it 'is not fooled by one-liner methods, syntax #2' do
inspect_source(cop, ['def one_line(test) 10 end',
'def self.m()',
' a = 1',
' a = 2',
' a = 4',
' a = 5',
' a = 6',
'end'])
expect(cop.offenses).to be_empty
end
it 'checks class methods, syntax #1' do
inspect_source(cop, ['def self.m()',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' a = 6',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.map(&:line).sort).to eq([1])
end
it 'checks class methods, syntax #2' do
inspect_source(cop, ['class K',
' class << self',
' def m()',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' a = 6',
' end',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.map(&:line).sort).to eq([3])
end
it 'properly counts lines when method ends with block' do
inspect_source(cop, ['def m()',
' something do',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.map(&:line).sort).to eq([1])
end
it 'does not count commented lines by default' do
inspect_source(cop, ['def m()',
' a = 1',
' #a = 2',
' a = 3',
' #a = 4',
' a = 5',
' a = 6',
'end'])
expect(cop.offenses).to be_empty
end
context 'when CountComments is enabled' do
before { cop_config['CountComments'] = true }
it 'also counts commented lines' do
inspect_source(cop, ['def m()',
' a = 1',
' #a = 2',
' a = 3',
' #a = 4',
' a = 5',
' a = 6',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.map(&:line).sort).to eq([1])
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/metrics/module_length_spec.rb 0000664 0000000 0000000 00000015351 13070542236 0026161 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Metrics::ModuleLength, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'Max' => 5, 'CountComments' => false } }
it 'rejects a module with more than 5 lines' do
inspect_source(cop, ['module Test',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' a = 6',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Module has too many lines. [6/5]'])
expect(cop.config_to_allow_offenses).to eq('Max' => 6)
end
it 'reports the correct beginning and end lines' do
inspect_source(cop, ['module Test',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' a = 6',
'end'])
offense = cop.offenses.first
expect(offense.location.first_line).to eq(1)
expect(offense.location.last_line).to eq(8)
end
it 'accepts a module with 5 lines' do
inspect_source(cop, ['module Test',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts a module with less than 5 lines' do
inspect_source(cop, ['module Test',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not count blank lines' do
inspect_source(cop, ['module Test',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
'',
'',
' a = 7',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts empty modules' do
inspect_source(cop, ['module Test',
'end'])
expect(cop.offenses).to be_empty
end
context 'when a module has inner modules' do
it 'does not count lines of inner modules' do
inspect_source(cop, ['module NamespaceModule',
' module TestOne',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' end',
' module TestTwo',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' end',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
'end'])
expect(cop.offenses).to be_empty
end
it 'rejects a module with 6 lines that belong to the module directly' do
inspect_source(cop, ['module NamespaceModule',
' module TestOne',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' end',
' module TestTwo',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' end',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' a = 6',
'end'])
expect(cop.offenses.size).to eq(1)
end
end
context 'when a module has inner classes' do
it 'does not count lines of inner classes' do
inspect_source(cop, ['module NamespaceModule',
' class TestOne',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' end',
' class TestTwo',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' end',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
'end'])
expect(cop.offenses).to be_empty
end
it 'rejects a module with 6 lines that belong to the module directly' do
inspect_source(cop, ['module NamespaceModule',
' class TestOne',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' end',
' class TestTwo',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' end',
' a = 1',
' a = 2',
' a = 3',
' a = 4',
' a = 5',
' a = 6',
'end'])
expect(cop.offenses.size).to eq(1)
end
end
context 'when CountComments is enabled' do
before { cop_config['CountComments'] = true }
it 'also counts commented lines' do
inspect_source(cop, ['module Test',
' a = 1',
' #a = 2',
' a = 3',
' #a = 4',
' a = 5',
' a = 6',
'end'])
expect(cop.offenses.size).to eq(1)
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/metrics/parameter_lists_spec.rb 0000664 0000000 0000000 00000003134 13070542236 0026525 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Metrics::ParameterLists, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) do
{
'Max' => 4,
'CountKeywordArgs' => true
}
end
it 'registers an offense for a method def with 5 parameters' do
inspect_source(cop, ['def meth(a, b, c, d, e)',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['Avoid parameter lists longer than 4 parameters. [5/4]']
)
expect(cop.config_to_allow_offenses).to eq('Max' => 5)
end
it 'accepts a method def with 4 parameters' do
inspect_source(cop, ['def meth(a, b, c, d)',
'end'])
expect(cop.offenses).to be_empty
end
context 'When CountKeywordArgs is true' do
it 'counts keyword arguments as well' do
inspect_source(cop, ['def meth(a, b, c, d: 1, e: 2)',
'end'])
expect(cop.messages).to eq(
['Avoid parameter lists longer than 4 parameters. [5/4]']
)
expect(cop.offenses.size).to eq(1)
end
end
context 'When CountKeywordArgs is false' do
before { cop_config['CountKeywordArgs'] = false }
it 'does not count keyword arguments' do
inspect_source(cop, ['def meth(a, b, c, d: 1, e: 2)',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not count keyword arguments without default values', ruby: 2.1 do
inspect_source(cop, ['def meth(a, b, c, d:, e:)',
'end'])
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/metrics/perceived_complexity_spec.rb 0000664 0000000 0000000 00000020571 13070542236 0027556 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Metrics::PerceivedComplexity, :config do
subject(:cop) { described_class.new(config) }
context 'when Max is 1' do
let(:cop_config) { { 'Max' => 1 } }
it 'accepts a method with no decision points' do
inspect_source(cop, ['def method_name',
' call_foo',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts complex code outside of methods' do
inspect_source(cop,
['def method_name',
' call_foo',
'end',
'',
'if first_condition then',
' call_foo if second_condition && third_condition',
' call_bar if fourth_condition || fifth_condition',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for an if modifier' do
inspect_source(cop, ['def self.method_name',
' call_foo if some_condition',
'end'])
expect(cop.messages)
.to eq(['Perceived complexity for method_name is too high. [2/1]'])
expect(cop.highlights).to eq(['def'])
expect(cop.config_to_allow_offenses).to eq('Max' => 2)
end
it 'registers an offense for an unless modifier' do
inspect_source(cop, ['def method_name',
' call_foo unless some_condition',
'end'])
expect(cop.messages)
.to eq(['Perceived complexity for method_name is too high. [2/1]'])
end
it 'registers an offense for elsif and else blocks' do
inspect_source(cop, ['def method_name',
' if first_condition then',
' call_foo',
' elsif second_condition then',
' call_bar',
' else',
' call_bam',
' end',
'end'])
expect(cop.messages)
.to eq(['Perceived complexity for method_name is too high. [4/1]'])
end
it 'registers an offense for a ternary operator' do
inspect_source(cop, ['def method_name',
' value = some_condition ? 1 : 2',
'end'])
expect(cop.messages)
.to eq(['Perceived complexity for method_name is too high. [2/1]'])
end
it 'registers an offense for a while block' do
inspect_source(cop, ['def method_name',
' while some_condition do',
' call_foo',
' end',
'end'])
expect(cop.messages)
.to eq(['Perceived complexity for method_name is too high. [2/1]'])
end
it 'registers an offense for an until block' do
inspect_source(cop, ['def method_name',
' until some_condition do',
' call_foo',
' end',
'end'])
expect(cop.messages)
.to eq(['Perceived complexity for method_name is too high. [2/1]'])
end
it 'registers an offense for a for block' do
inspect_source(cop, ['def method_name',
' for i in 1..2 do',
' call_method',
' end',
'end'])
expect(cop.messages)
.to eq(['Perceived complexity for method_name is too high. [2/1]'])
end
it 'registers an offense for a rescue block' do
inspect_source(cop, ['def method_name',
' begin',
' call_foo',
' rescue Exception',
' call_bar',
' end',
'end'])
expect(cop.messages)
.to eq(['Perceived complexity for method_name is too high. [2/1]'])
end
it 'registers an offense for a case/when block' do
inspect_source(cop, ['def method_name',
' case value',
' when 1 then call_foo_1',
' when 2 then call_foo_2',
' when 3 then call_foo_3',
' when 4 then call_foo_4',
' end',
'end'])
# The `case` node plus the first `when` score one complexity point
# together. The other `when` nodes get 0.2 complexity points.
expect(cop.messages)
.to eq(['Perceived complexity for method_name is too high. [3/1]'])
end
it 'registers an offense for a case/when block without an expression ' \
'after case' do
inspect_source(cop, ['def method_name',
' case',
' when value == 1',
' call_foo',
' when value == 2',
' call_bar',
' end',
'end'])
# Here, the `case` node doesn't count, but each when scores one
# complexity point.
expect(cop.messages)
.to eq(['Perceived complexity for method_name is too high. [3/1]'])
end
it 'registers an offense for &&' do
inspect_source(cop, ['def method_name',
' call_foo && call_bar',
'end'])
expect(cop.messages)
.to eq(['Perceived complexity for method_name is too high. [2/1]'])
end
it 'registers an offense for and' do
inspect_source(cop, ['def method_name',
' call_foo and call_bar',
'end'])
expect(cop.messages)
.to eq(['Perceived complexity for method_name is too high. [2/1]'])
end
it 'registers an offense for ||' do
inspect_source(cop, ['def method_name',
' call_foo || call_bar',
'end'])
expect(cop.messages)
.to eq(['Perceived complexity for method_name is too high. [2/1]'])
end
it 'registers an offense for or' do
inspect_source(cop, ['def method_name',
' call_foo or call_bar',
'end'])
expect(cop.messages)
.to eq(['Perceived complexity for method_name is too high. [2/1]'])
end
it 'deals with nested if blocks containing && and ||' do
inspect_source(cop,
['def method_name',
' if first_condition then',
' call_foo if second_condition && third_condition',
' call_bar if fourth_condition || fifth_condition',
' end',
'end'])
expect(cop.messages)
.to eq(['Perceived complexity for method_name is too high. [6/1]'])
end
it 'counts only a single method' do
inspect_source(cop, ['def method_name_1',
' call_foo if some_condition',
'end',
'',
'def method_name_2',
' call_foo if some_condition',
'end'])
expect(cop.messages)
.to eq(['Perceived complexity for method_name_1 is too high. [2/1]',
'Perceived complexity for method_name_2 is too high. [2/1]'])
end
end
context 'when Max is 2' do
let(:cop_config) { { 'Max' => 2 } }
it 'counts stupid nested if and else blocks' do
inspect_source(cop, ['def method_name', # 1
' if first_condition then', # 2
' call_foo',
' else', # 3
' if second_condition then', # 4
' call_bar',
' else', # 5
' call_bam if third_condition', # 6
' end',
' call_baz if fourth_condition', # 7
' end',
'end'])
expect(cop.messages)
.to eq(['Perceived complexity for method_name is too high. [7/2]'])
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/offense_spec.rb 0000664 0000000 0000000 00000012240 13070542236 0023304 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Offense do
let(:location) do
source_buffer = Parser::Source::Buffer.new('test', 1)
source_buffer.source = "a\n"
Parser::Source::Range.new(source_buffer, 0, 1)
end
subject(:offense) do
described_class.new(:convention, location, 'message', 'CopName', :corrected)
end
it 'has a few required attributes' do
expect(offense.severity).to eq(:convention)
expect(offense.line).to eq(1)
expect(offense.message).to eq('message')
expect(offense.cop_name).to eq('CopName')
expect(offense.corrected?).to be_truthy
expect(offense.highlighted_area.source).to eq('a')
end
it 'overrides #to_s' do
expect(offense.to_s).to eq('C: 1: 1: message')
end
it 'does not blow up if a message contains %' do
offense = described_class.new(:convention, location, 'message % test',
'CopName')
expect(offense.to_s).to eq('C: 1: 1: message % test')
end
it 'redefines == to compare offenses based on their contents' do
o1 = described_class.new(:convention, location, 'message', 'CopName')
o2 = described_class.new(:convention, location, 'message', 'CopName')
expect(o1 == o2).to be_truthy
end
it 'is frozen' do
expect(offense).to be_frozen
end
%i[severity location message cop_name].each do |a|
describe "##{a}" do
it 'is frozen' do
expect(offense.send(a)).to be_frozen
end
end
end
context 'when unknown severity is passed' do
it 'raises error' do
expect do
described_class.new(:foobar, location, 'message', 'CopName')
end.to raise_error(ArgumentError)
end
end
describe '#severity_level' do
subject(:severity_level) do
described_class.new(severity, location, 'message', 'CopName')
.severity
.level
end
context 'when severity is :refactor' do
let(:severity) { :refactor }
it 'is 1' do
expect(severity_level).to eq(1)
end
end
context 'when severity is :fatal' do
let(:severity) { :fatal }
it 'is 5' do
expect(severity_level).to eq(5)
end
end
end
describe '#<=>' do
def offense(hash = {})
attrs = {
sev: :convention,
line: 5,
col: 5,
mes: 'message',
cop: 'CopName'
}.merge(hash)
described_class.new(
attrs[:sev],
location(attrs[:line], attrs[:col],
%w[aaaaaa bbbbbb cccccc dddddd eeeeee ffffff]),
attrs[:mes],
attrs[:cop]
)
end
def location(line, column, source)
source_buffer = Parser::Source::Buffer.new('test', 1)
source_buffer.source = source.join("\n")
begin_pos = source[0...(line - 1)].reduce(0) do |a, e|
a + e.length + 1
end + column
Parser::Source::Range.new(source_buffer, begin_pos, begin_pos + 1)
end
# We want a nice table layout, so we allow space inside empty hashes.
# rubocop:disable Style/SpaceInsideHashLiteralBraces, Style/ExtraSpacing
[
[{ }, { }, 0],
[{ line: 6 }, { line: 5 }, 1],
[{ line: 5, col: 6 }, { line: 5, col: 5 }, 1],
[{ line: 6, col: 4 }, { line: 5, col: 5 }, 1],
[{ cop: 'B' }, { cop: 'A' }, 1],
[{ line: 6, cop: 'A' }, { line: 5, cop: 'B' }, 1],
[{ col: 6, cop: 'A' }, { col: 5, cop: 'B' }, 1]
].each do |one, other, expectation|
context "when receiver has #{one} and other has #{other}" do
it "returns #{expectation}" do
an_offense = offense(one)
other_offense = offense(other)
expect(an_offense <=> other_offense).to eq(expectation)
end
end
end
end
context 'offenses that span multiple lines' do
let(:location) do
source_buffer = Parser::Source::Buffer.new('test', 1)
source_buffer.source = ['def foo',
' something',
' something_else',
'end'].join("\n")
Parser::Source::Range.new(source_buffer, 0, source_buffer.source.length)
end
subject(:offense) do
described_class
.new(:convention, location, 'message', 'CopName', :corrected)
end
it 'highlights the first line' do
expect(offense.location.source).to eq(location.source_buffer.source)
expect(offense.highlighted_area.source).to eq('def foo')
end
end
context 'offenses that span part of a line' do
let(:location) do
source_buffer = Parser::Source::Buffer.new('test', 1)
source_buffer.source = ['def Foo',
' something',
' something_else',
'end'].join("\n")
Parser::Source::Range.new(source_buffer, 4, 7)
end
subject(:offense) do
described_class
.new(:convention, location, 'message', 'CopName', :corrected)
end
it 'highlights the first line' do
expect(offense.highlighted_area.source).to eq('Foo')
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/performance/ 0000775 0000000 0000000 00000000000 13070542236 0022622 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/performance/case_when_splat_spec.rb 0000664 0000000 0000000 00000036022 13070542236 0027323 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Performance::CaseWhenSplat do
subject(:cop) { described_class.new }
it 'allows case when without splat' do
inspect_source(cop, ['case foo',
'when 1',
' bar',
'else',
' baz',
'end'])
expect(cop.messages).to be_empty
end
it 'allows splat on a variable in the last when condition' do
inspect_source(cop, ['case foo',
'when 4',
' foobar',
'when *cond',
' bar',
'else',
' baz',
'end'])
expect(cop.messages).to be_empty
end
it 'allows multiple splat conditions on variables at the end' do
inspect_source(cop, ['case foo',
'when 4',
' foobar',
'when *cond1',
' bar',
'when *cond2',
' doo',
'else',
' baz',
'end'])
expect(cop.messages).to be_empty
end
it 'registers an offense for case when with a splat in the first condition' do
inspect_source(cop, ['case foo',
'when *cond',
' bar',
'when 4',
' foobar',
'else',
' baz',
'end'])
expect(cop.messages).to eq([described_class::MSG])
expect(cop.highlights).to eq(['when *cond'])
end
it 'registers an offense for case when with a splat without an else' do
inspect_source(cop, ['case foo',
'when *baz',
' bar',
'when 4',
' foobar',
'end'])
expect(cop.messages).to eq([described_class::MSG])
expect(cop.highlights).to eq(['when *baz'])
end
it 'registers an offense for splat conditions in when then' do
inspect_source(cop, ['case foo',
'when *cond then bar',
'when 4 then baz',
'end'])
expect(cop.messages).to eq([described_class::MSG])
expect(cop.highlights).to eq(['when *cond'])
end
it 'registers an offense for a single when with splat expansion followed ' \
'by another value' do
inspect_source(cop, ['case foo',
'when *Foo, Bar',
' nil',
'end'])
expect(cop.messages).to eq([described_class::MSG])
expect(cop.highlights).to eq(['when *Foo'])
end
it 'registers an offense for multiple splat conditions at the beginning' do
inspect_source(cop, ['case foo',
'when *cond1',
' bar',
'when *cond2',
' doo',
'when 4',
' foobar',
'else',
' baz',
'end'])
expect(cop.messages).to eq([described_class::MSG, described_class::MSG])
expect(cop.highlights).to eq(['when *cond1', 'when *cond2'])
end
it 'registers an offense for multiple out of order splat conditions' do
inspect_source(cop, ['case foo',
'when *cond1',
' bar',
'when 8',
' barfoo',
'when *SOME_CONSTANT',
' doo',
'when 4',
' foobar',
'else',
' baz',
'end'])
expect(cop.messages).to eq([described_class::MSG, described_class::MSG])
expect(cop.highlights).to eq(['when *cond1', 'when *SOME_CONSTANT'])
end
it 'registers an offense for splat condition that do not appear at the end' do
inspect_source(cop, ['case foo',
'when *cond1',
' bar',
'when 8',
' barfoo',
'when *cond2',
' doo',
'when 4',
' foobar',
'when *cond3',
' doofoo',
'else',
' baz',
'end'])
expect(cop.messages).to eq([described_class::MSG, described_class::MSG])
expect(cop.highlights).to eq(['when *cond1', 'when *cond2'])
end
it 'allows splat expansion on an array literal' do
inspect_source(cop, ['case foo',
'when *[1, 2]',
' bar',
'when *[3, 4]',
' bar',
'when 5',
' baz',
'end'])
expect(cop.offenses).to be_empty
end
it 'allows splat expansion on array literal as the last condition' do
inspect_source(cop, ['case foo',
'when *[1, 2]',
' bar',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for a splat on a variable that proceeds a splat ' \
'on an array literal as the last condition' do
inspect_source(cop, ['case foo',
'when *cond',
' bar',
'when *[1, 2]',
' baz',
'end'])
expect(cop.messages).to eq([described_class::MSG])
expect(cop.highlights).to eq(['when *cond'])
end
it 'registers an offense when splat is part of the condition' do
inspect_source(cop, ['case foo',
'when cond1, *cond2',
' bar',
'when cond3',
' baz',
'end'])
expect(cop.messages).to eq([described_class::MSG])
expect(cop.highlights).to eq(['when cond1, *cond2'])
end
context 'autocorrect' do
it 'corrects a single when with splat expansion followed by ' \
'another value' do
source = ['case foo',
'when *Foo, Bar, Baz',
' nil',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['case foo',
'when Bar, Baz, *Foo',
' nil',
'end'].join("\n"))
end
it 'corrects a when with splat expansion followed by another value ' \
'when there are multiple whens' do
source = ['case foo',
'when *Foo, Bar',
' nil',
'when FooBar',
' 1',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['case foo',
'when FooBar',
' 1',
'when Bar, *Foo',
' nil',
'end'].join("\n"))
end
it 'corrects a when with multiple out of order splat expansions ' \
'followed by other values when there are multiple whens' do
source = ['case foo',
'when *Foo, Bar, *Baz, Qux',
' nil',
'when FooBar',
' 1',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['case foo',
'when FooBar',
' 1',
'when Bar, Qux, *Foo, *Baz',
' nil',
'end'].join("\n"))
end
it 'moves a single splat condition to the end of the when conditions' do
new_source = autocorrect_source(cop, ['case foo',
'when *cond',
' bar',
'when 3',
' baz',
'end'])
expect(new_source).to eq(['case foo',
'when 3',
' baz',
'when *cond',
' bar',
'end'].join("\n"))
end
it 'moves multiple splat condition to the end of the when conditions' do
new_source = autocorrect_source(cop, ['case foo',
'when *cond1',
' bar',
'when *cond2',
' foobar',
'when 5',
' baz',
'end'])
# CaseWhenSplat requires multiple rounds of correction to avoid
# "clobbering errors" from Source::Rewriter
cop = described_class.new
new_source = autocorrect_source(cop, new_source)
expect(new_source).to eq(['case foo',
'when 5',
' baz',
'when *cond1',
' bar',
'when *cond2',
' foobar',
'end'].join("\n"))
end
it 'moves multiple out of order splat condition to the end ' \
'of the when conditions' do
new_source = autocorrect_source(cop, ['case foo',
'when *cond1',
' bar',
'when 3',
' doo',
'when *cond2',
' foobar',
'when 6',
' baz',
'end'])
# CaseWhenSplat requires multiple rounds of correction to avoid
# "clobbering errors" from Source::Rewriter
cop = described_class.new
new_source = autocorrect_source(cop, new_source)
expect(new_source).to eq(['case foo',
'when 3',
' doo',
'when 6',
' baz',
'when *cond1',
' bar',
'when *cond2',
' foobar',
'end'].join("\n"))
end
it 'corrects splat condition when using when then' do
new_source = autocorrect_source(cop, ['case foo',
'when *cond then bar',
'when 4 then baz',
'end'])
expect(new_source).to eq(['case foo',
'when 4 then baz',
'when *cond then bar',
'end'].join("\n"))
end
it 'corrects nested case when statements' do
new_source = autocorrect_source(cop, ['def check',
' case foo',
' when *cond',
' bar',
' when 3',
' baz',
' end',
'end'])
expect(new_source).to eq(['def check',
' case foo',
' when 3',
' baz',
' when *cond',
' bar',
' end',
'end'].join("\n"))
end
it 'corrects splat on a variable and leaves an array literal alone' do
new_source = autocorrect_source(cop, ['case foo',
'when *cond',
' bar',
'when *[1, 2]',
' baz',
'end'])
expect(new_source).to eq(['case foo',
'when *[1, 2]',
' baz',
'when *cond',
' bar',
'end'].join("\n"))
end
it 'corrects a splat as part of the condition' do
new_source = autocorrect_source(cop, ['case foo',
'when cond1, *cond2',
' bar',
'when cond3',
' baz',
'end'])
expect(new_source).to eq(['case foo',
'when cond3',
' baz',
'when cond1, *cond2',
' bar',
'end'].join("\n"))
end
it 'corrects an array followed by splat in the same condition' do
new_source = autocorrect_source(cop, ['case foo',
'when *[cond1, cond2], *cond3',
' bar',
'when cond4',
' baz',
'end'])
expect(new_source).to eq(['case foo',
'when cond4',
' baz',
'when *[cond1, cond2], *cond3',
' bar',
'end'].join("\n"))
end
it 'corrects a splat followed by array in the same condition' do
new_source = autocorrect_source(cop, ['case foo',
'when *cond1, *[cond2, cond3]',
' bar',
'when cond4',
' baz',
'end'])
expect(new_source).to eq(['case foo',
'when cond4',
' baz',
'when *cond1, *[cond2, cond3]',
' bar',
'end'].join("\n"))
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/performance/casecmp_spec.rb 0000664 0000000 0000000 00000011763 13070542236 0025604 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Performance::Casecmp do
subject(:cop) { described_class.new }
shared_examples 'selectors' do |selector|
it "autocorrects str.#{selector} ==" do
new_source = autocorrect_source(cop, "str.#{selector} == 'string'")
expect(new_source).to eq "str.casecmp('string').zero?"
end
it "autocorrects str.#{selector} == with parens around arg" do
new_source = autocorrect_source(cop, "str.#{selector} == ('string')")
expect(new_source).to eq "str.casecmp('string').zero?"
end
it "autocorrects str.#{selector} !=" do
new_source = autocorrect_source(cop, "str.#{selector} != 'string'")
expect(new_source).to eq "!str.casecmp('string').zero?"
end
it "autocorrects str.#{selector} != with parens around arg" do
new_source = autocorrect_source(cop, "str.#{selector} != ('string')")
expect(new_source).to eq "!str.casecmp('string').zero?"
end
it "autocorrects str.#{selector}.eql? without parens" do
new_source = autocorrect_source(cop, "str.#{selector}.eql? 'string'")
expect(new_source).to eq "str.casecmp('string').zero?"
end
it "autocorrects str.#{selector}.eql? with parens" do
new_source = autocorrect_source(cop, "str.#{selector}.eql?('string')")
expect(new_source).to eq "str.casecmp('string').zero?"
end
it "autocorrects str.#{selector}.eql? with parens and funny spacing" do
new_source = autocorrect_source(cop, "str.#{selector}.eql? ( 'string' )")
expect(new_source).to eq "str.casecmp( 'string' ).zero?"
end
it "autocorrects == str.#{selector}" do
new_source = autocorrect_source(cop, "'string' == str.#{selector}")
expect(new_source).to eq "str.casecmp('string').zero?"
end
it "autocorrects string with parens == str.#{selector}" do
new_source = autocorrect_source(cop, "('string') == str.#{selector}")
expect(new_source).to eq "str.casecmp('string').zero?"
end
it "autocorrects string != str.#{selector}" do
new_source = autocorrect_source(cop, "'string' != str.#{selector}")
expect(new_source).to eq "!str.casecmp('string').zero?"
end
it 'autocorrects string with parens and funny spacing ' \
"eql? str.#{selector}" do
new_source = autocorrect_source(cop, "( 'string' ).eql? str.#{selector}")
expect(new_source).to eq "str.casecmp( 'string' ).zero?"
end
it "autocorrects string.eql? str.#{selector} without parens " do
new_source = autocorrect_source(cop, "'string'.eql? str.#{selector}")
expect(new_source).to eq "str.casecmp('string').zero?"
end
it "autocorrects string.eql? str.#{selector} with parens " do
new_source = autocorrect_source(cop, "'string'.eql?(str.#{selector})")
expect(new_source).to eq "str.casecmp('string').zero?"
end
it "autocorrects obj.#{selector} == str.#{selector}" do
new_source = autocorrect_source(cop, "obj.#{selector} == str.#{selector}")
expect(new_source).to eq "obj.casecmp(str.#{selector}).zero?"
end
it "autocorrects obj.#{selector} eql? str.#{selector}" do
new_source = autocorrect_source(cop,
"obj.#{selector}.eql? str.#{selector}")
expect(new_source).to eq "obj.casecmp(str.#{selector}).zero?"
end
it "formats the error message correctly for str.#{selector} ==" do
inspect_source(cop, "str.#{selector} == 'string'")
expect(cop.highlights).to eq(["#{selector} =="])
expect(cop.messages).to eq(["Use `casecmp` instead of `#{selector} ==`."])
end
it "formats the error message correctly for == str.#{selector}" do
inspect_source(cop, "'string' == str.#{selector}")
expect(cop.highlights).to eq(["== str.#{selector}"])
expect(cop.messages).to eq(["Use `casecmp` instead of `== #{selector}`."])
end
it 'formats the error message correctly for ' \
"obj.#{selector} == str.#{selector}" do
inspect_source(cop, "obj.#{selector} == str.#{selector}")
expect(cop.highlights).to eq(["obj.#{selector} == str.#{selector}"])
expect(cop.messages).to eq(["Use `casecmp` instead of `#{selector} ==`."])
end
it "doesn't report an offense for variable == str.#{selector}" do
inspect_source(cop, ['var = "a"',
"var == str.#{selector}"])
expect(cop.offenses).to be_empty
end
it "doesn't report an offense for str.#{selector} == variable" do
inspect_source(cop, ['var = "a"',
"str.#{selector} == var"])
expect(cop.offenses).to be_empty
end
it "doesn't report an offense for obj.method == str.#{selector}" do
inspect_source(cop, "obj.method == str.#{selector}")
expect(cop.offenses).to be_empty
end
it "doesn't report an offense for str.#{selector} == obj.method" do
inspect_source(cop, "str.#{selector} == obj.method")
expect(cop.offenses).to be_empty
end
end
it_behaves_like('selectors', 'upcase')
it_behaves_like('selectors', 'downcase')
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/performance/compare_with_block_spec.rb 0000664 0000000 0000000 00000004117 13070542236 0030017 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Performance::CompareWithBlock do
subject(:cop) { described_class.new }
shared_examples 'compare with block' do |method|
it "registers an offense for #{method}" do
inspect_source(cop, "array.#{method} { |a, b| a.foo <=> b.foo }")
expect(cop.offenses.size).to eq(1)
end
it "accepts valid #{method} usage" do
inspect_source(cop, "array.#{method} { |a, b| b <=> a }")
expect(cop.offenses).to be_empty
end
it "accepts #{method}_by" do
inspect_source(cop, "array.#{method}_by { |a| a.baz }")
end
it "autocorrects array.#{method} { |a, b| a.foo <=> b.foo }" do
new_source =
autocorrect_source(cop, "array.#{method} { |a, b| a.foo <=> b.foo }")
expect(new_source).to eq "array.#{method}_by(&:foo)"
end
it "autocorrects array.#{method} { |a, b| a.bar <=> b.bar }" do
new_source =
autocorrect_source(cop, "array.#{method} { |a, b| a.bar <=> b.bar }")
expect(new_source).to eq "array.#{method}_by(&:bar)"
end
it "autocorrects array.#{method} { |x, y| x.foo <=> y.foo }" do
new_source =
autocorrect_source(cop, "array.#{method} { |x, y| x.foo <=> y.foo }")
expect(new_source).to eq "array.#{method}_by(&:foo)"
end
it "autocorrects array.#{method} do |a, b| a.foo <=> b.foo end" do
new_source = autocorrect_source(cop, ["array.#{method} do |a, b|",
' a.foo <=> b.foo',
'end'])
expect(new_source).to eq "array.#{method}_by(&:foo)"
end
it 'formats the error message correctly for ' \
"array.#{method} { |a, b| a.foo <=> b.foo }" do
inspect_source(cop, "array.#{method} { |a, b| a.foo <=> b.foo }")
expect(cop.messages).to eq(["Use `#{method}_by(&:foo)` instead of " \
"`#{method} { |a, b| a.foo <=> b.foo }`."])
end
end
include_examples 'compare with block', 'sort'
include_examples 'compare with block', 'max'
include_examples 'compare with block', 'min'
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/performance/count_spec.rb 0000664 0000000 0000000 00000024274 13070542236 0025322 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Performance::Count do
subject(:cop) { described_class.new }
shared_examples 'selectors' do |selector|
it "registers an offense for using array.#{selector}...size" do
inspect_source(cop, "[1, 2, 3].#{selector} { |e| e.even? }.size")
expect(cop.messages)
.to eq(["Use `count` instead of `#{selector}...size`."])
expect(cop.highlights).to eq(["#{selector} { |e| e.even? }.size"])
end
it "registers an offense for using hash.#{selector}...size" do
inspect_source(cop, "{a: 1, b: 2, c: 3}.#{selector} { |e| e == :a }.size")
expect(cop.messages)
.to eq(["Use `count` instead of `#{selector}...size`."])
expect(cop.highlights).to eq(["#{selector} { |e| e == :a }.size"])
end
it "registers an offense for using array.#{selector}...length" do
inspect_source(cop, "[1, 2, 3].#{selector} { |e| e.even? }.length")
expect(cop.messages)
.to eq(["Use `count` instead of `#{selector}...length`."])
expect(cop.highlights).to eq(["#{selector} { |e| e.even? }.length"])
end
it "registers an offense for using hash.#{selector}...length" do
inspect_source(cop, "{a: 1, b: 2}.#{selector} { |e| e == :a }.length")
expect(cop.messages)
.to eq(["Use `count` instead of `#{selector}...length`."])
expect(cop.highlights).to eq(["#{selector} { |e| e == :a }.length"])
end
it "registers an offense for using array.#{selector}...count" do
inspect_source(cop, "[1, 2, 3].#{selector} { |e| e.even? }.count")
expect(cop.messages)
.to eq(["Use `count` instead of `#{selector}...count`."])
expect(cop.highlights).to eq(["#{selector} { |e| e.even? }.count"])
end
it "registers an offense for using hash.#{selector}...count" do
inspect_source(cop, "{a: 1, b: 2}.#{selector} { |e| e == :a }.count")
expect(cop.messages)
.to eq(["Use `count` instead of `#{selector}...count`."])
expect(cop.highlights).to eq(["#{selector} { |e| e == :a }.count"])
end
it "allows usage of #{selector}...count with a block on an array" do
inspect_source(cop,
"[1, 2, 3].#{selector} { |e| e.odd? }.count { |e| e > 2 }")
expect(cop.messages).to be_empty
end
it "allows usage of #{selector}...count with a block on a hash" do
source = "{a: 1, b: 2}.#{selector} { |e| e == :a }.count { |e| e > 2 }"
inspect_source(cop, source)
expect(cop.messages).to be_empty
end
it "registers an offense for #{selector} with params instead of a block" do
inspect_source(cop, ['Data = Struct.new(:value)',
'array = [Data.new(2), Data.new(3), Data.new(2)]',
"puts array.#{selector}(&:value).count"].join("\n"))
expect(cop.messages)
.to eq(["Use `count` instead of `#{selector}...count`."])
expect(cop.highlights).to eq(["#{selector}(&:value).count"])
end
it "registers an offense for #{selector}(&:something).count" do
inspect_source(cop, "foo.#{selector}(&:something).count")
expect(cop.messages)
.to eq(["Use `count` instead of `#{selector}...count`."])
expect(cop.highlights).to eq(["#{selector}(&:something).count"])
end
it "registers an offense for #{selector}(&:something).count " \
'when called as an instance method on its own class' do
source = ['class A < Array',
' def count(&block)',
" #{selector}(&block).count",
' end',
'end']
inspect_source(cop, source)
expect(cop.messages)
.to eq(["Use `count` instead of `#{selector}...count`."])
expect(cop.highlights).to eq(["#{selector}(&block).count"])
end
it "allows usage of #{selector} without getting the size" do
inspect_source(cop, "[1, 2, 3].#{selector} { |e| e.even? }")
expect(cop.messages).to be_empty
end
context 'bang methods' do
it "allows usage of #{selector}!...size" do
inspect_source(cop,
"[1, 2, 3].#{selector}! { |e| e.odd? }.size")
expect(cop.messages).to be_empty
end
it "allows usage of #{selector}!...count" do
inspect_source(cop,
"[1, 2, 3].#{selector}! { |e| e.odd? }.count")
expect(cop.messages).to be_empty
end
it "allows usage of #{selector}!...length" do
inspect_source(cop,
"[1, 2, 3].#{selector}! { |e| e.odd? }.length")
expect(cop.messages).to be_empty
end
end
end
it_behaves_like('selectors', 'select')
it_behaves_like('selectors', 'reject')
context 'ActiveRecord select' do
it 'allows usage of select with a string' do
inspect_source(cop, "Model.select('field AS field_one').count")
expect(cop.messages).to be_empty
end
it 'allows usage of select with multiple strings' do
source = "Model.select('field AS field_one', 'other AS field_two').count"
inspect_source(cop, source)
expect(cop.messages).to be_empty
end
it 'allows usage of select with a symbol' do
inspect_source(cop, 'Model.select(:field).count')
expect(cop.messages).to be_empty
end
it 'allows usage of select with multiple symbols' do
inspect_source(cop, 'Model.select(:field, :other_field).count')
expect(cop.messages).to be_empty
end
end
it 'allows usage of another method with size' do
inspect_source(cop, '[1, 2, 3].map { |e| e + 1 }.size')
expect(cop.messages).to be_empty
end
it 'allows usage of size on an array' do
inspect_source(cop, '[1, 2, 3].size')
expect(cop.messages).to be_empty
end
it 'allows usage of count on an array' do
inspect_source(cop, '[1, 2, 3].count')
expect(cop.messages).to be_empty
end
it 'allows usage of count on an interstitial method called on select' do
inspect_source(cop, ['Data = Struct.new(:value)',
'array = [Data.new(2), Data.new(3), Data.new(2)]',
'puts array.select(&:value).uniq.count'].join("\n"))
expect(cop.messages).to be_empty
end
it 'allows usage of count on an interstitial method with blocks ' \
'called on select' do
inspect_source(cop, ['Data = Struct.new(:value)',
'array = [Data.new(2), Data.new(3), Data.new(2)]',
'array.select(&:value).uniq { |v| v > 2 }.count'])
expect(cop.messages).to be_empty
end
it 'allows usage of size called on an assigned variable' do
inspect_source(cop, ['nodes = [1]',
'nodes.size'].join("\n"))
expect(cop.messages).to be_empty
end
it 'allows usage of methods called on size' do
inspect_source(cop, 'shorter.size.to_f')
expect(cop.messages).to be_empty
end
context 'properly parses non related code' do
it 'will not raise an error for Bundler.setup' do
expect { inspect_source(cop, 'Bundler.setup(:default, :development)') }
.not_to raise_error
end
it 'will not raise an error for RakeTask.new' do
expect { inspect_source(cop, 'RakeTask.new(:spec)') }
.not_to raise_error
end
end
context 'autocorrect' do
context 'will correct' do
it 'select..size to count' do
new_source = autocorrect_source(cop, '[1, 2].select { |e| e > 2 }.size')
expect(new_source).to eq('[1, 2].count { |e| e > 2 }')
end
it 'select..count without a block to count' do
new_source = autocorrect_source(cop,
'[1, 2].select { |e| e > 2 }.count')
expect(new_source).to eq('[1, 2].count { |e| e > 2 }')
end
it 'select..length to count' do
new_source = autocorrect_source(cop,
'[1, 2].select { |e| e > 2 }.length')
expect(new_source).to eq('[1, 2].count { |e| e > 2 }')
end
it 'select...size when select has parameters' do
source = ['Data = Struct.new(:value)',
'array = [Data.new(2), Data.new(3), Data.new(2)]',
'puts array.select(&:value).size'].join("\n")
new_source = autocorrect_source(cop, source)
expect(new_source)
.to eq(['Data = Struct.new(:value)',
'array = [Data.new(2), Data.new(3), Data.new(2)]',
'puts array.count(&:value)'].join("\n"))
end
end
describe 'will not correct' do
it 'reject...size' do
new_source = autocorrect_source(cop, '[1, 2].reject { |e| e > 2 }.size')
expect(new_source).to eq('[1, 2].reject { |e| e > 2 }.size')
end
it 'reject...count' do
new_source = autocorrect_source(cop,
'[1, 2].reject { |e| e > 2 }.count')
expect(new_source).to eq('[1, 2].reject { |e| e > 2 }.count')
end
it 'reject...length' do
new_source = autocorrect_source(cop,
'[1, 2].reject { |e| e > 2 }.length')
expect(new_source).to eq('[1, 2].reject { |e| e > 2 }.length')
end
it 'select...count when count has a block' do
source = '[1, 2].select { |e| e > 2 }.count { |e| e.even? }'
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
it 'reject...size when select has parameters' do
source = ['Data = Struct.new(:value)',
'array = [Data.new(2), Data.new(3), Data.new(2)]',
'puts array.reject(&:value).size'].join("\n")
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
end
end
context 'SafeMode true' do
subject(:cop) { described_class.new(config) }
let(:config) do
RuboCop::Config.new(
'Rails' => {
'Enabled' => true
},
'Performance/Count' => {
'SafeMode' => true
}
)
end
shared_examples 'selectors' do |selector|
it "allows using array.#{selector}...size" do
inspect_source(cop, "[1, 2, 3].#{selector} { |e| e.even? }.size")
expect(cop.offenses).to be_empty
end
end
it_behaves_like('selectors', 'select')
it_behaves_like('selectors', 'reject')
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/performance/detect_spec.rb 0000664 0000000 0000000 00000017213 13070542236 0025435 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Performance::Detect do
subject(:cop) { described_class.new(config) }
let(:collection_method) { nil }
let(:config) do
RuboCop::Config.new(
'Style/CollectionMethods' => {
'PreferredMethods' => {
'detect' => collection_method
}
}
)
end
# rspec will not let you use a variable assigned using let outside
# of `it`
select_methods = %i[select find_all].freeze
select_methods.each do |method|
it "registers an offense when first is called on #{method}" do
inspect_source(cop, "[1, 2, 3].#{method} { |i| i % 2 == 0 }.first")
expect(cop.messages)
.to eq(["Use `detect` instead of `#{method}.first`."])
end
it "doesn't register an offense when first(n) is called on #{method}" do
inspect_source(cop, "[1, 2, 3].#{method} { |i| i % 2 == 0 }.first(n)")
expect(cop.offenses).to be_empty
end
it "registers an offense when last is called on #{method}" do
inspect_source(cop, "[1, 2, 3].#{method} { |i| i % 2 == 0 }.last")
expect(cop.messages)
.to eq(["Use `reverse.detect` instead of `#{method}.last`."])
end
it "doesn't register an offense when last(n) is called on #{method}" do
inspect_source(cop, "[1, 2, 3].#{method} { |i| i % 2 == 0 }.last(n)")
expect(cop.offenses).to be_empty
end
it "registers an offense when first is called on multiline #{method}" do
inspect_source(cop, ["[1, 2, 3].#{method} do |i|",
' i % 2 == 0',
'end.first'])
expect(cop.messages).to eq(["Use `detect` instead of `#{method}.first`."])
end
it "registers an offense when last is called on multiline #{method}" do
inspect_source(cop, ["[1, 2, 3].#{method} do |i|",
' i % 2 == 0',
'end.last'])
expect(cop.messages)
.to eq(["Use `reverse.detect` instead of `#{method}.last`."])
end
it "registers an offense when first is called on #{method} short syntax" do
inspect_source(cop, "[1, 2, 3].#{method}(&:even?).first")
expect(cop.messages).to eq(["Use `detect` instead of `#{method}.first`."])
end
it "registers an offense when last is called on #{method} short syntax" do
inspect_source(cop, "[1, 2, 3].#{method}(&:even?).last")
expect(cop.messages)
.to eq(["Use `reverse.detect` instead of `#{method}.last`."])
end
it "registers an offense when #{method} is called" \
'on `lazy` without receiver' do
inspect_source(cop, "lazy.#{method}(&:even?).first")
expect(cop.messages).to eq(["Use `detect` instead of `#{method}.first`."])
end
it "does not register an offense when #{method} is used " \
'without first or last' do
inspect_source(cop, "[1, 2, 3].#{method} { |i| i % 2 == 0 }")
expect(cop.messages).to be_empty
end
it "does not register an offense when #{method} is called" \
'without block or args' do
inspect_source(cop, "adapter.#{method}.first")
expect(cop.messages).to be_empty
end
it "does not register an offense when #{method} is called" \
'with args but without ampersand syntax' do
inspect_source(cop, "adapter.#{method}('something').first")
expect(cop.messages).to be_empty
end
it "does not register an offense when #{method} is called" \
'on lazy enumerable' do
inspect_source(cop, "adapter.lazy.#{method} { 'something' }.first")
expect(cop.messages).to be_empty
end
end
it 'does not register an offense when detect is used' do
inspect_source(cop, '[1, 2, 3].detect { |i| i % 2 == 0 }')
expect(cop.messages).to be_empty
end
context 'autocorrect' do
shared_examples 'detect_autocorrect' do |preferred_method|
context "with #{preferred_method}" do
let(:collection_method) { preferred_method }
select_methods.each do |method|
it "corrects #{method}.first to #{preferred_method} (with block)" do
source = "[1, 2, 3].#{method} { |i| i % 2 == 0 }.first"
new_source = autocorrect_source(cop, source)
expect(new_source)
.to eq("[1, 2, 3].#{preferred_method} { |i| i % 2 == 0 }")
end
it "corrects #{method}.last to reverse.#{preferred_method} " \
'(with block)' do
source = "[1, 2, 3].#{method} { |i| i % 2 == 0 }.last"
new_source = autocorrect_source(cop, source)
expect(new_source)
.to eq("[1, 2, 3].reverse.#{preferred_method} { |i| i % 2 == 0 }")
end
it "corrects #{method}.first to #{preferred_method} (short syntax)" do
source = "[1, 2, 3].#{method}(&:even?).first"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("[1, 2, 3].#{preferred_method}(&:even?)")
end
it "corrects #{method}.last to reverse.#{preferred_method} " \
'(short syntax)' do
source = "[1, 2, 3].#{method}(&:even?).last"
new_source = autocorrect_source(cop, source)
expect(new_source)
.to eq("[1, 2, 3].reverse.#{preferred_method}(&:even?)")
end
it "corrects #{method}.first to #{preferred_method} (multiline)" do
source = ["[1, 2, 3].#{method} do |i|",
' i % 2 == 0',
'end.first']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(["[1, 2, 3].#{preferred_method} do |i|",
' i % 2 == 0',
'end'].join("\n"))
end
it "corrects #{method}.last to reverse.#{preferred_method} " \
'(multiline)' do
source = ["[1, 2, 3].#{method} do |i|",
' i % 2 == 0',
'end.last']
new_source = autocorrect_source(cop, source)
expect(new_source)
.to eq(["[1, 2, 3].reverse.#{preferred_method} do |i|",
' i % 2 == 0',
'end'].join("\n"))
end
it "corrects multiline #{method} to #{preferred_method} " \
"with 'first' on the last line" do
source = ["[1, 2, 3].#{method} { true }",
".first['x']"]
new_source = autocorrect_source(cop, source)
expect(new_source)
.to eq("[1, 2, 3].#{preferred_method} { true }['x']")
end
it "corrects multiline #{method} to #{preferred_method} " \
"with 'first' on the last line (short syntax)" do
source = ["[1, 2, 3].#{method}(&:blank?)",
".first['x']"]
new_source = autocorrect_source(cop, source)
expect(new_source)
.to eq("[1, 2, 3].#{preferred_method}(&:blank?)['x']")
end
end
end
end
it_behaves_like 'detect_autocorrect', 'detect'
it_behaves_like 'detect_autocorrect', 'find'
end
context 'SafeMode true' do
let(:config) do
RuboCop::Config.new(
'Rails' => {
'Enabled' => true
},
'Style/CollectionMethods' => {
'PreferredMethods' => {
'detect' => collection_method
}
},
'Performance/Detect' => {
'SafeMode' => true
}
)
end
select_methods.each do |method|
it "doesn't register an offense when first is called on #{method}" do
inspect_source(cop, "[1, 2, 3].#{method} { |i| i % 2 == 0 }.first")
expect(cop.offenses).to be_empty
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/performance/double_start_end_with_spec.rb 0000664 0000000 0000000 00000021337 13070542236 0030537 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Performance::DoubleStartEndWith do
subject(:cop) { described_class.new(config) }
context 'IncludeActiveSupportAliases: false' do
let(:config) do
RuboCop::Config.new(
'Performance/DoubleStartEndWith' => {
'IncludeActiveSupportAliases' => false
}
)
end
context 'two #start_with? calls' do
context 'with the same receiver' do
context 'all parameters of the second call are pure' do
let(:source) { 'x.start_with?(a, b) || x.start_with?("c", D)' }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(
'Use `x.start_with?(a, b, "c", D)` instead of ' \
'`x.start_with?(a, b) || x.start_with?("c", D)`.'
)
expect(cop.highlights).to eq(
['x.start_with?(a, b) || x.start_with?("c", D)']
)
end
it 'corrects to a single start_with?' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('x.start_with?(a, b, "c", D)')
end
end
context 'one of the parameters of the second call is not pure' do
let(:source) { 'x.start_with?(a, "b") || x.start_with?(C, d)' }
it "doesn't register an offense" do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
context 'with different receivers' do
let(:source) { 'x.start_with?("a") || y.start_with?("b")' }
it "doesn't register an offense" do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
context 'two #end_with? calls' do
context 'with the same receiver' do
context 'all parameters of the second call are pure' do
let(:source) { 'x.end_with?(a, b) || x.end_with?("c", D)' }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(
'Use `x.end_with?(a, b, "c", D)` instead of ' \
'`x.end_with?(a, b) || x.end_with?("c", D)`.'
)
expect(cop.highlights).to eq(
['x.end_with?(a, b) || x.end_with?("c", D)']
)
end
it 'corrects to a single end_with?' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('x.end_with?(a, b, "c", D)')
end
end
context 'one of the parameters of the second call is not pure' do
let(:source) { 'x.end_with?(a, "b") || x.end_with?(C, d)' }
it "doesn't register an offense" do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
context 'with different receivers' do
let(:source) { 'x.end_with?("a") || y.end_with?("b")' }
it "doesn't register an offense" do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
context 'a .start_with? and .end_with? call with the same receiver' do
let(:source) { 'x.start_with?("a") || x.end_with?("b")' }
it "doesn't register an offense" do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
context 'two #starts_with? calls' do
let(:source) { 'x.starts_with?(a, b) || x.starts_with?("c", D)' }
it "doesn't register an offense" do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
context 'two #ends_with? calls' do
let(:source) { 'x.ends_with?(a, b) || x.ends_with?("c", D)' }
it "doesn't register an offense" do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
context 'IncludeActiveSupportAliases: true' do
let(:config) do
RuboCop::Config.new(
'Performance/DoubleStartEndWith' => {
'IncludeActiveSupportAliases' => true
}
)
end
context 'two #start_with? calls' do
context 'with the same receiver' do
context 'all parameters of the second call are pure' do
let(:source) { 'x.start_with?(a, b) || x.start_with?("c", D)' }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Use `x.start_with?(a, b, "c", D)` instead of ' \
'`x.start_with?(a, b) || x.start_with?("c", D)`.')
expect(cop.highlights)
.to eq(['x.start_with?(a, b) || x.start_with?("c", D)'])
end
it 'corrects to a single start_with?' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('x.start_with?(a, b, "c", D)')
end
end
end
end
context 'two #end_with? calls' do
context 'with the same receiver' do
context 'all parameters of the second call are pure' do
let(:source) { 'x.end_with?(a, b) || x.end_with?("c", D)' }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message)
.to eq('Use `x.end_with?(a, b, "c", D)` instead of ' \
'`x.end_with?(a, b) || x.end_with?("c", D)`.')
expect(cop.highlights)
.to eq(['x.end_with?(a, b) || x.end_with?("c", D)'])
end
it 'corrects to a single end_with?' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('x.end_with?(a, b, "c", D)')
end
end
end
end
context 'two #starts_with? calls' do
context 'with the same receiver' do
context 'all parameters of the second call are pure' do
let(:source) { 'x.starts_with?(a, b) || x.starts_with?("c", D)' }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(
'Use `x.starts_with?(a, b, "c", D)` instead of ' \
'`x.starts_with?(a, b) || x.starts_with?("c", D)`.'
)
expect(cop.highlights).to eq(
['x.starts_with?(a, b) || x.starts_with?("c", D)']
)
end
it 'corrects to a single starts_with?' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('x.starts_with?(a, b, "c", D)')
end
end
context 'one of the parameters of the second call is not pure' do
let(:source) { 'x.starts_with?(a, "b") || x.starts_with?(C, d)' }
it "doesn't register an offense" do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
context 'with different receivers' do
let(:source) { 'x.starts_with?("a") || y.starts_with?("b")' }
it "doesn't register an offense" do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
context 'two #ends_with? calls' do
context 'with the same receiver' do
context 'all parameters of the second call are pure' do
let(:source) { 'x.ends_with?(a, b) || x.ends_with?("c", D)' }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(
'Use `x.ends_with?(a, b, "c", D)` instead of ' \
'`x.ends_with?(a, b) || x.ends_with?("c", D)`.'
)
expect(cop.highlights).to eq(
['x.ends_with?(a, b) || x.ends_with?("c", D)']
)
end
it 'corrects to a single ends_with?' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('x.ends_with?(a, b, "c", D)')
end
end
context 'one of the parameters of the second call is not pure' do
let(:source) { 'x.ends_with?(a, "b") || x.ends_with?(C, d)' }
it "doesn't register an offense" do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
context 'with different receivers' do
let(:source) { 'x.ends_with?("a") || y.ends_with?("b")' }
it "doesn't register an offense" do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/performance/end_with_spec.rb 0000664 0000000 0000000 00000005443 13070542236 0025770 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Performance::EndWith do
subject(:cop) { described_class.new }
shared_examples 'different match methods' do |method|
it "autocorrects #{method} /abc\\z/" do
new_source = autocorrect_source(cop, "str#{method} /abc\\z/")
expect(new_source).to eq "str.end_with?('abc')"
end
it "autocorrects #{method} /\\n\\z/" do
new_source = autocorrect_source(cop, "str#{method} /\\n\\z/")
expect(new_source).to eq 'str.end_with?("\n")'
end
it "autocorrects #{method} /\\t\\z/" do
new_source = autocorrect_source(cop, "str#{method} /\\t\\z/")
expect(new_source).to eq 'str.end_with?("\t")'
end
%w[. $ ^ |].each do |str|
it "autocorrects #{method} /\\#{str}\\z/" do
new_source = autocorrect_source(cop, "str#{method} /\\#{str}\\z/")
expect(new_source).to eq "str.end_with?('#{str}')"
end
it "doesn't register an error for #{method} /#{str}\\z/" do
inspect_source(cop, "str#{method} /#{str}\\z/")
expect(cop.messages).to be_empty
end
end
# escapes like "\n"
# note that "\b" is a literal backspace char in a double-quoted string...
# but in a regex, it's an anchor on a word boundary
%w[a e f r t v].each do |str|
it "autocorrects #{method} /\\#{str}\\z/" do
new_source = autocorrect_source(cop, "str#{method} /\\#{str}\\z/")
expect(new_source).to eq %{str.end_with?("\\#{str}")}
end
end
# character classes, anchors
%w[w W s S d D A Z z G b B h H R X S].each do |str|
it "doesn't register an error for #{method} /\\#{str}\\z/" do
inspect_source(cop, "str#{method} /\\#{str}\\z/")
expect(cop.messages).to be_empty
end
end
# characters with no special meaning whatsoever
%w[i j l m o q y].each do |str|
it "autocorrects #{method} /\\#{str}\\z/" do
new_source = autocorrect_source(cop, "str#{method} /\\#{str}\\z/")
expect(new_source).to eq "str.end_with?('#{str}')"
end
end
it "formats the error message correctly for #{method} /abc\\z/" do
inspect_source(cop, "str#{method} /abc\\z/")
expect(cop.messages).to eq(['Use `String#end_with?` instead of a ' \
'regex match anchored to the end of ' \
'the string.'])
end
it "autocorrects #{method} /\\\\\\z/" do
new_source = autocorrect_source(cop, "str#{method} /\\\\\\z/")
expect(new_source).to eq("str.end_with?('\\\\')")
end
end
include_examples('different match methods', ' =~')
include_examples('different match methods', '.match')
it 'allows match without a receiver' do
inspect_source(cop, 'expect(subject.spin).to match(/\n\z/)')
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/performance/fixed_size_spec.rb 0000664 0000000 0000000 00000015610 13070542236 0026315 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Performance::FixedSize do
subject(:cop) { described_class.new }
shared_examples :common_functionality do |method|
context 'strings' do
it "registers an offense when calling #{method} on a single quoted " \
'string' do
inspect_source(cop, "'a'.#{method}")
expect(cop.messages).to eq([described_class::MSG])
end
it "registers an offense when calling #{method} on a double quoted " \
'string' do
inspect_source(cop, "\"a\".#{method}")
expect(cop.messages).to eq([described_class::MSG])
end
it "registers an offense when calling #{method} on a %q string" do
inspect_source(cop, "%q(a).#{method}")
expect(cop.messages).to eq([described_class::MSG])
end
it "registers an offense when calling #{method} on a %Q string" do
inspect_source(cop, "%Q(a).#{method}")
expect(cop.messages).to eq([described_class::MSG])
end
it "registers an offense when calling #{method} on a % string" do
inspect_source(cop, "%(a).#{method}")
expect(cop.messages).to eq([described_class::MSG])
end
it "accepts calling #{method} on a double quoted string that " \
'contains interpolation' do
inspect_source(cop, "\"\#{foo}\".#{method}")
expect(cop.messages).to be_empty
end
it "accepts calling #{method} on a %Q string that contains " \
'interpolation' do
inspect_source(cop, "\%Q(\#{foo}).#{method}")
expect(cop.messages).to be_empty
end
it "accepts calling #{method} on a % string that contains " \
'interpolation' do
inspect_source(cop, "\%(\#{foo}).#{method}")
expect(cop.messages).to be_empty
end
it "accepts calling #{method} on a single quoted string that " \
'is assigned to a constant' do
inspect_source(cop, "CONST = 'a'.#{method}")
expect(cop.messages).to be_empty
end
it "accepts calling #{method} on a double quoted string that " \
'is assigned to a constant' do
inspect_source(cop, "CONST = \"a\".#{method}")
expect(cop.messages).to be_empty
end
it "accepts calling #{method} on a %q string that is assigned to " \
'a constant' do
inspect_source(cop, "CONST = %q(a).#{method}")
expect(cop.messages).to be_empty
end
it "accepts calling #{method} on a variable " do
inspect_source(cop, ['foo = "abc"',
"foo.#{method}"])
expect(cop.messages).to be_empty
end
end
context 'symbols' do
it "registers an offense when calling #{method} on a symbol" do
inspect_source(cop, ":foo.#{method}")
expect(cop.messages).to eq([described_class::MSG])
end
it "registers an offense when calling #{method} on a quoted symbol" do
inspect_source(cop, ":'foo-bar'.#{method}")
expect(cop.messages).to eq([described_class::MSG])
end
it "accepts calling #{method} on an interpolated quoted symbol" do
inspect_source(cop, ":\"foo-\#{bar}\".#{method}")
expect(cop.messages).to be_empty
end
it "registers an offense when calling #{method} on %s" do
inspect_source(cop, "%s(foo-bar).#{method}")
expect(cop.messages).to eq([described_class::MSG])
end
it "accepts calling #{method} on a symbol that is assigned " \
'to a constant' do
inspect_source(cop, "CONST = :foo.#{method}")
expect(cop.messages).to be_empty
end
end
context 'arrays' do
it "registers an offense when calling #{method} on an array using []" do
inspect_source(cop, "[1, 2, foo].#{method}")
expect(cop.messages).to eq([described_class::MSG])
end
it "registers an offense when calling #{method} on an array using %w" do
inspect_source(cop, "%w(1, 2, foo).#{method}")
expect(cop.messages).to eq([described_class::MSG])
end
it "registers an offense when calling #{method} on an array using %W" do
inspect_source(cop, "%W(1, 2, foo).#{method}")
expect(cop.messages).to eq([described_class::MSG])
end
it "accepts calling #{method} on an array using [] that contains " \
'a splat' do
inspect_source(cop, "[1, 2, *foo].#{method}")
expect(cop.messages).to be_empty
end
it "accepts calling #{method} on array that is set to a variable" do
inspect_source(cop, ['foo = [1, 2, 3]',
"foo.#{method}"])
expect(cop.messages).to be_empty
end
it "accepts calling #{method} on an array that is assigned " \
'to a constant' do
inspect_source(cop, "CONST = [1, 2, 3].#{method}")
expect(cop.messages).to be_empty
end
end
context 'hashes' do
it "registers an offense when calling #{method} on a hash using {}" do
inspect_source(cop, "{a: 1, b: 2}.#{method}")
expect(cop.messages).to eq([described_class::MSG])
end
it "accepts calling #{method} on a hash set to a variable" do
inspect_source(cop, ['foo = {a: 1, b: 2}',
"foo.#{method}"])
expect(cop.messages).to be_empty
end
context 'ruby >= 2.0', :ruby20 do
it "accepts calling #{method} on a hash that contains a double splat" do
inspect_source(cop, "{a: 1, **foo}.#{method}")
expect(cop.messages).to be_empty
end
end
it "accepts calling #{method} on an hash that is assigned " \
'to a constant' do
inspect_source(cop, "CONST = {a: 1, b: 2}.#{method}")
expect(cop.messages).to be_empty
end
end
end
it_behaves_like :common_functionality, 'size'
it_behaves_like :common_functionality, 'length'
it_behaves_like :common_functionality, 'count'
shared_examples :count_with_arguments do |variable|
it 'accepts calling count with a variable' do
inspect_source(cop, "#{variable}.count(bar)")
expect(cop.messages).to be_empty
end
it 'accepts calling count with an instance variable' do
inspect_source(cop, "#{variable}.count(@bar)")
expect(cop.messages).to be_empty
end
it 'registers an offense when calling count with a string' do
inspect_source(cop, "#{variable}.count('o')")
expect(cop.messages).to eq([described_class::MSG])
end
it 'accepts calling count with a block' do
inspect_source(cop, "#{variable}.count { |v| v == 'a' }")
expect(cop.messages).to be_empty
end
it 'accepts calling count with a symbol proc' do
inspect_source(cop, "#{variable}.count(&:any?) ")
expect(cop.messages).to be_empty
end
end
it_behaves_like :count_with_arguments, '"foo"'
it_behaves_like :count_with_arguments, '[1, 2, 3]'
it_behaves_like :count_with_arguments, '{a: 1, b: 2}'
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/performance/flat_map_spec.rb 0000664 0000000 0000000 00000007633 13070542236 0025755 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Performance::FlatMap, :config do
subject(:cop) { described_class.new(config) }
shared_examples 'map_and_collect' do |method, flatten|
it "registers an offense when calling #{method}...#{flatten}(1)" do
inspect_source(cop, "[1, 2, 3, 4].#{method} { |e| [e, e] }.#{flatten}(1)")
expect(cop.messages)
.to eq(["Use `flat_map` instead of `#{method}...#{flatten}`."])
expect(cop.highlights).to eq(["#{method} { |e| [e, e] }.#{flatten}(1)"])
end
it "does not register an offense when calling #{method}...#{flatten} " \
'with a number greater than 1' do
inspect_source(cop, "[1, 2, 3, 4].#{method} { |e| [e, e] }.#{flatten}(3)")
expect(cop.messages).to be_empty
end
it "does not register an offense when calling #{method}!...#{flatten}" do
inspect_source(cop, "[1, 2, 3, 4].#{method}! { |e| [e, e] }.#{flatten}")
expect(cop.messages).to be_empty
end
it "corrects #{method}..#{flatten}(1) to flat_map" do
source = "[1, 2].#{method} { |e| [e, e] }.#{flatten}(1)"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('[1, 2].flat_map { |e| [e, e] }')
end
end
describe 'configured to only warn when flattening one level' do
let(:config) do
RuboCop::Config.new('Performance/FlatMap' => {
'Enabled' => true,
'EnabledForFlattenWithoutParams' => false
})
end
shared_examples 'flatten_with_params_disabled' do |method, flatten|
it "does not register an offense when calling #{method}...#{flatten}" do
inspect_source(cop, "[1, 2, 3, 4].map { |e| [e, e] }.#{flatten}")
expect(cop.messages).to be_empty
end
end
it_behaves_like('map_and_collect', 'map', 'flatten')
it_behaves_like('map_and_collect', 'map', 'flatten!')
it_behaves_like('map_and_collect', 'collect', 'flatten')
it_behaves_like('map_and_collect', 'collect', 'flatten!')
it_behaves_like('flatten_with_params_disabled', 'map', 'flatten')
it_behaves_like('flatten_with_params_disabled', 'collect', 'flatten')
it_behaves_like('flatten_with_params_disabled', 'map', 'flatten!')
it_behaves_like('flatten_with_params_disabled', 'collect', 'flatten!')
end
describe 'configured to warn when flatten is not called with parameters' do
let(:config) do
RuboCop::Config.new('Performance/FlatMap' => {
'Enabled' => true,
'EnabledForFlattenWithoutParams' => true
})
end
shared_examples 'flatten_with_params_enabled' do |method, flatten|
it "registers an offense when calling #{method}...#{flatten}" do
inspect_source(cop, "[1, 2, 3, 4].map { |e| [e, e] }.#{flatten}")
expect(cop.messages)
.to eq(["Use `flat_map` instead of `map...#{flatten}`. " \
'Beware, `flat_map` only flattens 1 level and `flatten` ' \
'can be used to flatten multiple levels.'])
expect(cop.highlights).to eq(["map { |e| [e, e] }.#{flatten}"])
end
it "will not correct #{method}..#{flatten} to flat_map" do
source = "[1, 2].map { |e| [e, e] }.#{flatten}"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("[1, 2].map { |e| [e, e] }.#{flatten}")
end
end
it_behaves_like('map_and_collect', 'map', 'flatten')
it_behaves_like('map_and_collect', 'map', 'flatten!')
it_behaves_like('map_and_collect', 'collect', 'flatten')
it_behaves_like('map_and_collect', 'collect', 'flatten!')
it_behaves_like('flatten_with_params_enabled', 'map', 'flatten')
it_behaves_like('flatten_with_params_enabled', 'collect', 'flatten')
it_behaves_like('flatten_with_params_enabled', 'map', 'flatten!')
it_behaves_like('flatten_with_params_enabled', 'collect', 'flatten!')
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/performance/hash_each_methods_spec.rb 0000664 0000000 0000000 00000005026 13070542236 0027612 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Performance::HashEachMethods do
subject(:cop) { described_class.new }
it 'registers an offense for Hash#keys.each' do
inspect_source(cop, 'hash.keys.each { |k| p k }')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `each_key` instead of `keys.each`.'])
end
it 'registers an offense for Hash#values.each' do
inspect_source(cop, 'hash.values.each { |v| p v }')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `each_value` instead of `values.each`.'])
end
it 'registers an offense for Hash#each with unused value' do
inspect_source(cop, 'hash.each { |k, _v| p k }')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `each_key` instead of `each`.'])
end
it 'registers an offense for Hash#each with unused key' do
inspect_source(cop, 'hash.each { |_k, v| p v }')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `each_value` instead of `each`.'])
end
it 'does not register an offense for Hash#each_key' do
inspect_source(cop, 'hash.each_key { |k| p k }')
expect(cop.messages).to be_empty
end
it 'does not register an offense for Hash#each_value' do
inspect_source(cop, 'hash.each_value { |v| p v }')
expect(cop.messages).to be_empty
end
it 'does not register an offense for Hash#each if both key/value are used' do
inspect_source(cop, 'hash.each { |k, v| p "#{k}_#{v}" }')
expect(cop.messages).to be_empty
end
it 'does not register an offense for Hash#each if block takes only one arg' do
inspect_source(cop, 'hash.each { |kv| p kv }')
expect(cop.messages).to be_empty
end
it 'auto-corrects Hash#keys.each with Hash#each_key' do
new_source = autocorrect_source(cop, 'hash.keys.each { |k| p k }')
expect(new_source).to eq('hash.each_key { |k| p k }')
end
it 'auto-corrects Hash#values.each with Hash#each_value' do
new_source = autocorrect_source(cop, 'hash.values.each { |v| p v }')
expect(new_source).to eq('hash.each_value { |v| p v }')
end
it 'auto-corrects Hash#each with unused value argument with Hash#each_key' do
new_source = autocorrect_source(cop, 'hash.each { |k, _v| p k }')
expect(new_source).to eq('hash.each_key { |k| p k }')
end
it 'auto-corrects Hash#each with unused key argument with Hash#each_value' do
new_source = autocorrect_source(cop, 'hash.each { |_k, v| p v }')
expect(new_source).to eq('hash.each_value { |v| p v }')
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/performance/lstrip_rstrip_spec.rb 0000664 0000000 0000000 00000001161 13070542236 0027100 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Performance::LstripRstrip do
subject(:cop) { described_class.new }
it 'autocorrects str.lstrip.rstrip' do
new_source = autocorrect_source(cop, 'str.lstrip.rstrip')
expect(new_source).to eq 'str.strip'
end
it 'autocorrects str.rstrip.lstrip' do
new_source = autocorrect_source(cop, 'str.rstrip.lstrip')
expect(new_source).to eq 'str.strip'
end
it 'formats the error message correctly for str.lstrip.rstrip' do
inspect_source(cop, 'str.lstrip.rstrip')
expect(cop.messages).to eq(['Use `strip` instead of `lstrip.rstrip`.'])
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/performance/range_include_spec.rb 0000664 0000000 0000000 00000002003 13070542236 0026753 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Performance::RangeInclude do
subject(:cop) { described_class.new }
it 'autocorrects (a..b).include? without parens' do
new_source = autocorrect_source(cop, '(a..b).include? 1')
expect(new_source).to eq '(a..b).cover? 1'
end
it 'autocorrects (a...b).include? without parens' do
new_source = autocorrect_source(cop, '(a...b).include? 1')
expect(new_source).to eq '(a...b).cover? 1'
end
it 'autocorrects (a..b).include? with parens' do
new_source = autocorrect_source(cop, '(a..b).include?(1)')
expect(new_source).to eq '(a..b).cover?(1)'
end
it 'autocorrects (a...b).include? with parens' do
new_source = autocorrect_source(cop, '(a...b).include?(1)')
expect(new_source).to eq '(a...b).cover?(1)'
end
it 'formats the error message correctly for (a..b).include? 1' do
inspect_source(cop, '(a..b).include? 1')
expect(cop.messages).to eq(
['Use `Range#cover?` instead of `Range#include?`.']
)
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/performance/redundant_block_call_spec.rb 0000664 0000000 0000000 00000012123 13070542236 0030311 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Performance::RedundantBlockCall do
subject(:cop) { described_class.new }
it 'autocorrects block.call without arguments' do
new_source = autocorrect_source(cop, ['def method(&block)',
' block.call',
'end'])
expect(new_source).to eq(['def method(&block)',
' yield',
'end'].join("\n"))
end
it 'autocorrects block.call with empty parentheses' do
new_source = autocorrect_source(cop, ['def method(&block)',
' block.call()',
'end'])
expect(new_source).to eq(['def method(&block)',
' yield',
'end'].join("\n"))
end
it 'autocorrects block.call with arguments' do
new_source = autocorrect_source(cop, ['def method(&block)',
' block.call 1, 2',
'end'])
expect(new_source).to eq(['def method(&block)',
' yield 1, 2',
'end'].join("\n"))
end
it 'autocorrects multiple occurances of block.call with arguments' do
new_source = autocorrect_source(cop, ['def method(&block)',
' block.call 1',
' block.call 2',
'end'])
expect(new_source).to eq(['def method(&block)',
' yield 1',
' yield 2',
'end'].join("\n"))
end
it 'autocorrects even when block arg has a different name' do
new_source = autocorrect_source(cop, ['def method(&func)',
' func.call',
'end'])
expect(new_source).to eq(['def method(&func)',
' yield',
'end'].join("\n"))
end
it 'accepts a block that is not `call`ed' do
inspect_source(cop, ['def method(&block)',
' something.call',
'end'])
expect(cop.messages).to be_empty
end
it 'accepts an empty method body' do
inspect_source(cop, ['def method(&block)',
'end'])
expect(cop.messages).to be_empty
end
it 'accepts another block being passed as the only arg' do
inspect_source(cop, ['def method(&block)',
' block.call(&some_proc)',
'end'])
expect(cop.messages).to be_empty
end
it 'accepts another block being passed along with other args' do
inspect_source(cop, ['def method(&block)',
' block.call(1, &some_proc)',
'end'])
expect(cop.messages).to be_empty
end
it 'accepts another block arg in at least one occurance of block.call' do
inspect_source(cop, ['def method(&block)',
' block.call(1, &some_proc)',
' block.call(2)',
'end'])
expect(cop.messages).to be_empty
end
it 'accepts an optional block that is defaulted' do
inspect_source(cop, ['def method(&block)',
' block ||= ->(i) { puts i }',
' block.call(1)',
'end'])
expect(cop.messages).to be_empty
end
it 'accepts an optional block that is overridden' do
inspect_source(cop, ['def method(&block)',
' block = ->(i) { puts i }',
' block.call(1)',
'end'])
expect(cop.messages).to be_empty
end
it 'formats the error message for func.call(1) correctly' do
inspect_source(cop, ['def method(&func)',
' func.call(1)',
'end'])
expect(cop.messages).to eq(['Use `yield` instead of `func.call`.'])
end
it 'autocorrects using parentheses when block.call uses parentheses' do
new_source = autocorrect_source(cop, ['def method(&block)',
' block.call(a, b)',
'end'])
expect(new_source).to eq(['def method(&block)',
' yield(a, b)',
'end'].join("\n"))
end
it 'autocorrects when the result of the call is used in a scope that ' \
'requires parentheses' do
source = ['def method(&block)',
' each_with_object({}) do |(key, value), acc|',
' acc.merge!(block.call(key) => rhs[value])',
' end',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['def method(&block)',
' each_with_object({}) do |(key, value), acc|',
' acc.merge!(yield(key) => rhs[value])',
' end',
'end'].join("\n"))
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/performance/redundant_match_spec.rb 0000664 0000000 0000000 00000007241 13070542236 0027325 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
# do_something if str.match(/regex/)
# while regex.match('str')
# do_something
# end
#
# @good
# method(str.match(/regex/))
# return regex.match('str')
describe RuboCop::Cop::Performance::RedundantMatch do
subject(:cop) { described_class.new }
it 'autocorrects .match in if condition' do
new_source = autocorrect_source(cop, 'something if str.match(/regex/)')
expect(new_source).to eq 'something if str =~ /regex/'
end
it 'autocorrects .match in unless condition' do
new_source = autocorrect_source(cop, 'something unless str.match(/regex/)')
expect(new_source).to eq 'something unless str =~ /regex/'
end
it 'autocorrects .match in while condition' do
new_source = autocorrect_source(cop, ['while str.match(/regex/)',
' do_something',
'end'])
expect(new_source).to eq(['while str =~ /regex/',
' do_something',
'end'].join("\n"))
end
it 'autocorrects .match in until condition' do
new_source = autocorrect_source(cop, ['until str.match(/regex/)',
' do_something',
'end'])
expect(new_source).to eq(['until str =~ /regex/',
' do_something',
'end'].join("\n"))
end
it 'autocorrects .match in method body (but not tail position)' do
new_source = autocorrect_source(cop, ['def method(str)',
' str.match(/regex/)',
' true',
'end'])
expect(new_source).to eq(['def method(str)',
' str =~ /regex/',
' true',
'end'].join("\n"))
end
it 'does not autocorrect if .match has a string agrgument' do
new_source = autocorrect_source(cop, 'something if str.match("string")')
expect(new_source).to eq 'something if str.match("string")'
end
it 'does not register an error when return value of .match is passed ' \
'to another method' do
inspect_source(cop, ['def method(str)',
' something(str.match(/regex/))',
'end'])
expect(cop.messages).to be_empty
end
it 'does not register an error when return value of .match is stored in an ' \
'instance variable' do
inspect_source(cop, ['def method(str)',
' @var = str.match(/regex/)',
' true',
'end'])
expect(cop.messages).to be_empty
end
it 'does not register an error when return value of .match is returned from' \
' surrounding method' do
inspect_source(cop, ['def method(str)',
' str.match(/regex/)',
'end'])
expect(cop.messages).to be_empty
end
it 'does not register an offense when match has a block' do
inspect_source(cop, ['/regex/.match(str) do |m|',
' something(m)',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register an error when there is no receiver to the match call' do
inspect_source(cop, 'match("bar")')
expect(cop.messages).to be_empty
end
it 'formats error message correctly for something if str.match(/regex/)' do
inspect_source(cop, 'something if str.match(/regex/)')
expect(cop.messages).to eq(['Use `=~` in places where the `MatchData` ' \
'returned by `#match` will not be used.'])
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/performance/redundant_merge_spec.rb 0000664 0000000 0000000 00000016740 13070542236 0027334 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Performance::RedundantMerge, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) do
{ 'MaxKeyValuePairs' => 2 }
end
it 'autocorrects hash.merge!(a: 1)' do
new_source = autocorrect_source(cop, 'hash.merge!(a: 1)')
expect(new_source).to eq 'hash[:a] = 1'
end
it 'autocorrects hash.merge!("abc" => "value")' do
new_source = autocorrect_source(cop, 'hash.merge!("abc" => "value")')
expect(new_source).to eq 'hash["abc"] = "value"'
end
context 'when receiver is a local variable' do
it 'autocorrects hash.merge!(a: 1, b: 2)' do
new_source = autocorrect_source(cop, ['hash = {}',
'hash.merge!(a: 1, b: 2)'])
expect(new_source).to eq(['hash = {}',
'hash[:a] = 1',
'hash[:b] = 2'].join("\n"))
end
end
context 'when receiver is a method call' do
it "doesn't autocorrect hash.merge!(a: 1, b: 2)" do
new_source = autocorrect_source(cop, 'hash.merge!(a: 1, b: 2)')
expect(new_source).to eq('hash.merge!(a: 1, b: 2)')
end
end
context 'when receiver is implicit' do
it "doesn't autocorrect" do
new_source = autocorrect_source(cop, 'merge!(foo: 1, bar: 2)')
expect(new_source).to eq('merge!(foo: 1, bar: 2)')
end
end
context 'when internal to each_with_object' do
it 'autocorrects when the receiver is the object being built' do
source = ['foo.each_with_object({}) do |f, hash|',
' hash.merge!(a: 1, b: 2)',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['foo.each_with_object({}) do |f, hash|',
' hash[:a] = 1',
' hash[:b] = 2',
'end'].join("\n"))
end
it 'autocorrects when the receiver is the object being built when ' \
'merge! is the last statement' do
source = ['foo.each_with_object({}) do |f, hash|',
' some_method',
' hash.merge!(a: 1, b: 2)',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['foo.each_with_object({}) do |f, hash|',
' some_method',
' hash[:a] = 1',
' hash[:b] = 2',
'end'].join("\n"))
end
it 'autocorrects when the receiver is the object being built when ' \
'merge! is not the last statement' do
source = ['foo.each_with_object({}) do |f, hash|',
' hash.merge!(a: 1, b: 2)',
' why_are_you_doing_this?',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['foo.each_with_object({}) do |f, hash|',
' hash[:a] = 1',
' hash[:b] = 2',
' why_are_you_doing_this?',
'end'].join("\n"))
end
it 'does not register an offense when merge! is being assigned inside ' \
'each_with_object' do
source = ['foo.each_with_object({}) do |f, hash|',
' changes = hash.merge!(a: 1, b: 2)',
' why_are_you_doing_this?',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'autocorrects when receiver uses element reference to the object ' \
'built by each_with_object' do
source = ['foo.each_with_object(bar) do |f, hash|',
' hash[:a].merge!(b: "")',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['foo.each_with_object(bar) do |f, hash|',
' hash[:a][:b] = ""',
'end'].join("\n"))
end
it 'autocorrects when receiver uses multiple element references to the ' \
'object built by each_with_object' do
source = ['foo.each_with_object(bar) do |f, hash|',
' hash[:a][:b].merge!(c: "")',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['foo.each_with_object(bar) do |f, hash|',
' hash[:a][:b][:c] = ""',
'end'].join("\n"))
end
it 'autocorrects merge! called on any method on the object built ' \
'by each_with_object' do
source = ['foo.each_with_object(bar) do |f, hash|',
' hash.bar.merge!(c: "")',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['foo.each_with_object(bar) do |f, hash|',
' hash.bar[:c] = ""',
'end'].join("\n"))
end
end
%w[if unless while until].each do |kw|
context "when there is a modifier #{kw}, and more than 1 pair" do
it "autocorrects it to an #{kw} block" do
new_source = autocorrect_source(
cop,
['hash = {}',
"hash.merge!(a: 1, b: 2) #{kw} condition1 && condition2"]
)
expect(new_source).to eq(['hash = {}',
"#{kw} condition1 && condition2",
' hash[:a] = 1',
' hash[:b] = 2',
'end'].join("\n"))
end
context 'when original code was indented' do
it 'maintains proper indentation' do
new_source = autocorrect_source(
cop,
['hash = {}',
'begin',
" hash.merge!(a: 1, b: 2) #{kw} condition1",
'end']
)
expect(new_source).to eq(['hash = {}',
'begin',
" #{kw} condition1",
' hash[:a] = 1',
' hash[:b] = 2',
' end',
'end'].join("\n"))
end
end
end
end
context 'when code is indented, and there is more than 1 pair' do
it 'indents the autocorrected code properly' do
new_source = autocorrect_source(cop, ['hash = {}',
'begin',
' hash.merge!(a: 1, b: 2)',
'end'])
expect(new_source).to eq(['hash = {}',
'begin',
' hash[:a] = 1',
' hash[:b] = 2',
'end'].join("\n"))
end
end
it "doesn't register an error when return value is used" do
inspect_source(cop, ['variable = hash.merge!(a: 1)',
'puts variable'])
expect(cop.offenses).to be_empty
end
it 'formats the error message correctly for hash.merge!(a: 1)' do
inspect_source(cop, 'hash.merge!(a: 1)')
expect(cop.messages).to eq(
['Use `hash[:a] = 1` instead of `hash.merge!(a: 1)`.']
)
end
context 'with MaxKeyValuePairs of 1' do
let(:cop_config) do
{ 'MaxKeyValuePairs' => 1 }
end
it "doesn't register errors for multi-value hash merges" do
inspect_source(cop, ['hash = {}',
'hash.merge!(a: 1, b: 2)'])
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/performance/redundant_sort_by_spec.rb 0000664 0000000 0000000 00000001645 13070542236 0027714 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Performance::RedundantSortBy do
subject(:cop) { described_class.new }
it 'autocorrects array.sort_by { |x| x }' do
new_source = autocorrect_source(cop, 'array.sort_by { |x| x }')
expect(new_source).to eq 'array.sort'
end
it 'autocorrects array.sort_by { |y| y }' do
new_source = autocorrect_source(cop, 'array.sort_by { |y| y }')
expect(new_source).to eq 'array.sort'
end
it 'autocorrects array.sort_by do |x| x end' do
new_source = autocorrect_source(cop, ['array.sort_by do |x|',
' x',
'end'])
expect(new_source).to eq 'array.sort'
end
it 'formats the error message correctly for array.sort_by { |x| x }' do
inspect_source(cop, 'array.sort_by { |x| x }')
expect(cop.messages).to eq(['Use `sort` instead of `sort_by { |x| x }`.'])
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/performance/regexp_match_spec.rb 0000664 0000000 0000000 00000016114 13070542236 0026632 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Performance::RegexpMatch, :config do
subject(:cop) { described_class.new(config) }
shared_examples :accepts do |name, code|
it "accepts usages of #{name}" do
inspect_source(cop, code)
expect(cop.offenses).to be_empty
end
end
shared_examples :offense do |name, code, correction|
it "registers an offense for #{name}" do
inspect_source(cop, code)
expect(cop.offenses.size).to eq(1)
end
it "corrects #{name}" do
new_source = autocorrect_source(cop, code)
expect(new_source).to eq(correction)
end
end
shared_examples :all_legacy_match_methods do |name, cond, correction|
include_examples :offense, "#{name} in if condition", <<-END, <<-END2
if #{cond}
do_something
end
END
if #{correction}
do_something
end
END2
include_examples :offense, "#{name} in unless condition", <<-END, <<-END2
unless #{cond}
do_something
end
END
unless #{correction}
do_something
end
END2
include_examples :offense, "#{name} in elsif condition", <<-END, <<-END2
if cond
do_something
elsif #{cond}
do_something2
end
END
if cond
do_something
elsif #{correction}
do_something2
end
END2
include_examples :offense, "#{name} in case condition", <<-END, <<-END2
case
when #{cond}
do_something
end
END
case
when #{correction}
do_something
end
END2
include_examples :offense, "#{name} in ternary operator", <<-END, <<-END2
#{cond} ? do_something : do_something2
END
#{correction} ? do_something : do_something2
END2
include_examples :offense, "#{name} in method definition", <<-END, <<-END2
def foo
if #{cond}
do_something
end
end
END
def foo
if #{correction}
do_something
end
end
END2
%w[
$& $' $` $~ $1 $2 $100
$MATCH
Regexp.last_match Regexp.last_match(1)
].each do |var|
include_examples :accepts, "#{name} in method with `#{var}`", <<-END
def foo
if #{cond}
do_something(#{var})
end
end
END
include_examples :accepts,
"#{name} in method with `#{var}` in block", <<-END
def foo
bar do
if #{cond}
do_something
end
end
puts #{var}
end
END
include_examples :offense,
"#{name} in method before `#{var}`", <<-END, <<-END2
def foo
do_something(#{var})
if #{cond}
do_something2
end
end
END
def foo
do_something(#{var})
if #{correction}
do_something2
end
end
END2
include_examples :offense,
"#{name} in method" \
", `#{var}` is in other method", <<-END, <<-END2
def foo
if #{cond}
do_something2
end
end
def bar
do_something(#{var})
end
END
def foo
if #{correction}
do_something2
end
end
def bar
do_something(#{var})
end
END2
include_examples :offense,
"#{name} in class method" \
", `#{var}` is in other method", <<-END, <<-END2
def self.foo
if #{cond}
do_something2
end
end
def self.bar
do_something(#{var})
end
END
def self.foo
if #{correction}
do_something2
end
end
def self.bar
do_something(#{var})
end
END2
include_examples :offense,
"#{name} in class" \
", `#{var}` is in method", <<-END, <<-END2
class Foo
if #{cond}
do_something
end
def foo
#{var}
end
end
END
class Foo
if #{correction}
do_something
end
def foo
#{var}
end
end
END2
include_examples :offense,
"#{name} in module" \
", `#{var}` is in method", <<-END, <<-END2
module Foo
if #{cond}
do_something
end
def foo
#{var}
end
end
END
module Foo
if #{correction}
do_something
end
def foo
#{var}
end
end
END2
include_examples :offense,
"#{name}, #{var} reference is overrided", <<-END, <<-END2
if #{cond}
do_something
#{cond}
#{var}
end
END
if #{correction}
do_something
#{cond}
#{var}
end
END2
end
end
context 'target ruby version < 2.4', :ruby23 do
[
['match method call in if condition', <<-END],
if foo.match(/re/)
do_something
end
END
['match method call in elsif condition', <<-END],
if cond
do_something
elsif foo.match(/re/)
do_something2
end
END
].each do |name, code|
include_examples :accepts, name, code
end
end
context 'target ruby version >= 2.4', :ruby24 do
[
['String#match method call', '"foo".match(re)', '"foo".match?(re)'],
['String#match method call with position',
'"foo".match(re, 1)',
'"foo".match?(re, 1)'],
['Regexp#match method call', '/re/.match(foo)', '/re/.match?(foo)'],
['Regexp#match method call with position',
'/re/.match(foo, 1)',
'/re/.match?(foo, 1)'],
['Symbol#match method call', ':foo.match(re)', ':foo.match?(re)'],
['Symbol#match method call with position',
':foo.match(re, 1)',
':foo.match?(re, 1)'],
['match method call for a variable',
'foo.match(/re/)',
'foo.match?(/re/)'],
['match method call for a variable with position',
'foo.match(/re/, 1)',
'foo.match?(/re/, 1)'],
['matching by =~`', '/re/ =~ foo', '/re/.match?(foo)'],
['matching by =~`', 'foo =~ /re/', 'foo.match?(/re/)'],
['matching by =~`', '"foo" =~ re', '"foo".match?(re)'],
['matching by =~`', ':foo =~ re', ':foo.match?(re)'],
['matching by ===`', '/re/ === foo', '/re/.match?(foo)'],
['matching by ===`', '/re/i === foo', '/re/i.match?(foo)']
].each do |name, code, correction|
include_examples :all_legacy_match_methods, name, code, correction
end
include_examples :accepts, '`Regexp#match?` method call', <<-END
if /re/.match?(str)
do_something
end
END
include_examples :accepts, '`String#match?` method call', <<-END
if str.match?(/re/)
do_something
end
END
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/performance/reverse_each_spec.rb 0000664 0000000 0000000 00000001643 13070542236 0026620 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Performance::ReverseEach do
subject(:cop) { described_class.new }
it 'registers an offense when each is called on reverse' do
inspect_source(cop, '[1, 2, 3].reverse.each { |e| puts e }')
expect(cop.messages)
.to eq(['Use `reverse_each` instead of `reverse.each`.'])
end
it 'does not register an offense when reverse is used without each' do
inspect_source(cop, '[1, 2, 3].reverse')
expect(cop.messages).to be_empty
end
it 'does not register an offense when each is used without reverse' do
inspect_source(cop, '[1, 2, 3].each { |e| puts e }')
expect(cop.messages).to be_empty
end
context 'autocorrect' do
it 'corrects reverse.each to reverse_each' do
new_source = autocorrect_source(cop, '[1, 2].reverse.each { |e| puts e }')
expect(new_source).to eq('[1, 2].reverse_each { |e| puts e }')
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/performance/sample_spec.rb 0000664 0000000 0000000 00000005605 13070542236 0025450 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Performance::Sample do
subject(:cop) { described_class.new }
shared_examples 'offense' do |wrong, right|
it "when using #{wrong}" do
inspect_source(cop, "[1, 2, 3].#{wrong}")
expect(cop.messages).to eq(["Use `#{right}` instead of `#{wrong}`."])
end
context 'corrects' do
it "#{wrong} to #{right}" do
new_source = autocorrect_source(cop, "[1, 2, 3].#{wrong}")
expect(new_source).to eq("[1, 2, 3].#{right}")
end
end
end
shared_examples 'accepts' do |acceptable|
it acceptable do
inspect_source(cop, "[1, 2, 3].#{acceptable}")
expect(cop.messages).to be_empty
end
end
it_behaves_like('offense', 'shuffle.first', 'sample')
it_behaves_like('offense', 'shuffle.last', 'sample')
it_behaves_like('offense', 'shuffle[0]', 'sample')
it_behaves_like('offense', 'shuffle[0, 3]', 'sample(3)')
it_behaves_like('offense', 'shuffle[0..3]', 'sample(4)')
it_behaves_like('offense', 'shuffle[0...3]', 'sample(3)')
it_behaves_like('offense', 'shuffle.first(2)', 'sample(2)')
it_behaves_like('offense', 'shuffle.last(3)', 'sample(3)')
it_behaves_like('offense', 'shuffle.first(foo)', 'sample(foo)')
it_behaves_like('offense', 'shuffle.last(bar)', 'sample(bar)')
it_behaves_like('offense', 'shuffle(random: Random.new).first',
'sample(random: Random.new)')
it_behaves_like('offense', 'shuffle(random: Random.new).first(2)',
'sample(2, random: Random.new)')
it_behaves_like('offense', 'shuffle(random: foo).last(bar)',
'sample(bar, random: foo)')
it_behaves_like('offense', 'shuffle(random: Random.new)[0..3]',
'sample(4, random: Random.new)')
it_behaves_like('accepts', 'sample')
it_behaves_like('accepts', 'shuffle')
it_behaves_like('accepts', 'shuffle[2]') # nil if coll.size < 3
it_behaves_like('accepts', 'shuffle[3, 3]') # nil if coll.size < 3
it_behaves_like('accepts', 'shuffle[2..3]') # empty if coll.size < 3
it_behaves_like('accepts', 'shuffle[2..-3]') # can't compute range size
it_behaves_like('accepts', 'shuffle[foo..3]') # can't compute range size
it_behaves_like('accepts', 'shuffle[-4..-3]') # nil if coll.size < 3
it_behaves_like('accepts', 'shuffle[foo]') # foo could be a Range
it_behaves_like('accepts', 'shuffle[foo, 3]') # nil if coll.size < foo
it_behaves_like('accepts', 'shuffle[foo..bar]')
it_behaves_like('accepts', 'shuffle[foo, bar]')
it_behaves_like('accepts', 'shuffle(random: Random.new)')
it_behaves_like('accepts', 'shuffle.join([5, 6, 7])')
it_behaves_like('accepts', 'shuffle.map { |e| e }')
it_behaves_like('accepts', 'shuffle(random: Random.new)[2]')
it_behaves_like('accepts', 'shuffle(random: Random.new)[2, 3]')
it_behaves_like('accepts', 'shuffle(random: Random.new).find(&:odd?)')
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/performance/size_spec.rb 0000664 0000000 0000000 00000010617 13070542236 0025140 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Performance::Size do
subject(:cop) { described_class.new }
it 'does not register an offense when calling count ' \
'as a stand alone method' do
inspect_source(cop, 'count(items)')
expect(cop.messages).to be_empty
end
it 'does not register an offense when calling count on an object ' \
'other than an array or a hash' do
inspect_source(cop, 'object.count(items)')
expect(cop.messages).to be_empty
end
describe 'on array' do
it 'registers an offense when calling count' do
inspect_source(cop, '[1, 2, 3].count')
expect(cop.messages).to eq(['Use `size` instead of `count`.'])
end
it 'registers an offense when calling count on to_a' do
inspect_source(cop, '(1..3).to_a.count')
expect(cop.messages).to eq(['Use `size` instead of `count`.'])
end
it 'registers an offense when calling count on Array[]' do
inspect_source(cop, 'Array[*1..5].count')
expect(cop.messages).to eq(['Use `size` instead of `count`.'])
end
it 'does not register an offense when calling size' do
inspect_source(cop, '[1, 2, 3].size')
expect(cop.messages).to be_empty
end
it 'does not register an offense when calling another method' do
inspect_source(cop, '[1, 2, 3].each')
expect(cop.messages).to be_empty
end
it 'does not register an offense when calling count with a block' do
inspect_source(cop, '[1, 2, 3].count { |e| e > 3 }')
expect(cop.messages).to be_empty
end
it 'does not register an offense when calling count with a to_proc block' do
inspect_source(cop, '[1, 2, 3].count(&:nil?)')
expect(cop.offenses).to be_empty
end
it 'does not register an offense when calling count with an argument' do
inspect_source(cop, '[1, 2, 3].count(1)')
expect(cop.offenses).to be_empty
end
it 'corrects count to size' do
new_source = autocorrect_source(cop, '[1, 2, 3].count')
expect(new_source).to eq('[1, 2, 3].size')
end
it 'corrects count to size on to_a' do
new_source = autocorrect_source(cop, '(1..3).to_a.count')
expect(new_source).to eq('(1..3).to_a.size')
end
it 'corrects count to size on Array[]' do
new_source = autocorrect_source(cop, 'Array[*1..5].count')
expect(new_source).to eq('Array[*1..5].size')
end
end
describe 'on hash' do
it 'registers an offense when calling count' do
inspect_source(cop, '{a: 1, b: 2, c: 3}.count')
expect(cop.messages).to eq(['Use `size` instead of `count`.'])
end
it 'registers an offense when calling count on to_h' do
inspect_source(cop, '[[:foo, :bar], [1, 2]].to_h.count')
expect(cop.messages).to eq(['Use `size` instead of `count`.'])
end
it 'registers an offense when calling count on Hash[]' do
inspect_source(cop, "Hash[*('a'..'z')].count")
expect(cop.messages).to eq(['Use `size` instead of `count`.'])
end
it 'does not register an offense when calling size' do
inspect_source(cop, '{a: 1, b: 2, c: 3}.size')
expect(cop.messages).to be_empty
end
it 'does not register an offense when calling another method' do
inspect_source(cop, '{a: 1, b: 2, c: 3}.each')
expect(cop.messages).to be_empty
end
it 'does not register an offense when calling count with a block' do
inspect_source(cop, '{a: 1, b: 2, c: 3}.count { |e| e > 3 }')
expect(cop.messages).to be_empty
end
it 'does not register an offense when calling count with a to_proc block' do
inspect_source(cop, '{a: 1, b: 2, c: 3}.count(&:nil?)')
expect(cop.offenses).to be_empty
end
it 'does not register an offense when calling count with an argument' do
inspect_source(cop, '{a: 1, b: 2, c: 3}.count(1)')
expect(cop.offenses).to be_empty
end
it 'corrects count to size' do
new_source = autocorrect_source(cop, '{a: 1, b: 2, c: 3}.count')
expect(new_source).to eq('{a: 1, b: 2, c: 3}.size')
end
it 'corrects count to size on to_h' do
new_source = autocorrect_source(cop, '[[:foo, :bar], [1, 2]].to_h.count')
expect(new_source).to eq('[[:foo, :bar], [1, 2]].to_h.size')
end
it 'corrects count to size on Hash[]' do
new_source = autocorrect_source(cop, "Hash[*('a'..'z')].count")
expect(new_source).to eq("Hash[*('a'..'z')].size")
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/performance/start_with_spec.rb 0000664 0000000 0000000 00000004773 13070542236 0026364 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Performance::StartWith do
subject(:cop) { described_class.new }
shared_examples 'different match methods' do |method|
it "autocorrects #{method} /\\Aabc/" do
new_source = autocorrect_source(cop, "str#{method} /\\Aabc/")
expect(new_source).to eq "str.start_with?('abc')"
end
# escapes like "\n"
# note that "\b" is a literal backspace char in a double-quoted string...
# but in a regex, it's an anchor on a word boundary
%w[a e f r t v].each do |str|
it "autocorrects #{method} /\\A\\#{str}/" do
new_source = autocorrect_source(cop, "str#{method} /\\A\\#{str}/")
expect(new_source).to eq %{str.start_with?("\\#{str}")}
end
end
# regexp metacharacters
%w[. * ? $ ^ |].each do |str|
it "autocorrects #{method} /\\A\\#{str}/" do
new_source = autocorrect_source(cop, "str#{method} /\\A\\#{str}/")
expect(new_source).to eq "str.start_with?('#{str}')"
end
it "doesn't register an error for #{method} /\\A#{str}/" do
inspect_source(cop, "str#{method} /\\A#{str}/")
expect(cop.messages).to be_empty
end
end
# character classes, anchors
%w[w W s S d D A Z z G b B h H R X S].each do |str|
it "doesn't register an error for #{method} /\\A\\#{str}/" do
inspect_source(cop, "str#{method} /\\A\\#{str}/")
expect(cop.messages).to be_empty
end
end
# characters with no special meaning whatsoever
%w[i j l m o q y].each do |str|
it "autocorrects #{method} /\\A\\#{str}/" do
new_source = autocorrect_source(cop, "str#{method} /\\A\\#{str}/")
expect(new_source).to eq "str.start_with?('#{str}')"
end
end
it "formats the error message correctly for #{method} /\\Aabc/" do
inspect_source(cop, "str#{method} /\\Aabc/")
expect(cop.messages).to eq(['Use `String#start_with?` instead of a ' \
'regex match anchored to the beginning of ' \
'the string.'])
end
it "autocorrects #{method} /\\A\\\\/" do
new_source = autocorrect_source(cop, "str#{method} /\\A\\\\/")
expect(new_source).to eq("str.start_with?('\\\\')")
end
end
include_examples('different match methods', ' =~')
include_examples('different match methods', '.match')
it 'allows match without a receiver' do
inspect_source(cop, 'expect(subject.spin).to match(/\A\n/)')
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/performance/string_replacement_spec.rb 0000664 0000000 0000000 00000032034 13070542236 0030050 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Performance::StringReplacement do
subject(:cop) { described_class.new }
it 'accepts methods other than gsub' do
inspect_source(cop, "'abc'.insert(2, 'a')")
expect(cop.messages).to be_empty
end
shared_examples 'accepts' do |method|
context 'non deterministic parameters' do
it 'accepts gsub when the length of the pattern is greater than 1' do
inspect_source(cop, "'abc'.#{method}('ab', 'de')")
expect(cop.messages).to be_empty
end
it 'accepts the first param being a variable' do
inspect_source(cop, ['regex = /a/',
"'abc'.#{method}(regex, '1')"])
expect(cop.messages).to be_empty
end
it 'accepts the second param being a variable' do
inspect_source(cop, ["replacement = 'e'",
"'abc'.#{method}('abc', replacement)"])
expect(cop.messages).to be_empty
end
it 'accepts the both params being a variables' do
inspect_source(cop, ['regex = /a/',
"replacement = 'e'",
"'abc'.#{method}(regex, replacement)"])
expect(cop.messages).to be_empty
end
it 'accepts gsub with only one param' do
inspect_source(cop, "'abc'.#{method}('a')")
expect(cop.messages).to be_empty
end
it 'accepts gsub with a block' do
inspect_source(cop, "'abc'.#{method}('a') { |s| s.upcase } ")
expect(cop.messages).to be_empty
end
it 'accepts a pattern with string interpolation' do
inspect_source(cop, ["foo = 'a'",
"'abc'.#{method}(\"\#{foo}\", '1')"])
expect(cop.messages).to be_empty
end
it 'accepts a replacement with string interpolation' do
inspect_source(cop, ["foo = '1'",
"'abc'.#{method}('a', \"\#{foo}\")"])
expect(cop.messages).to be_empty
end
it 'allows empty regex literal pattern' do
inspect_source(cop, "'abc'.#{method}(//, '1')")
expect(cop.messages).to be_empty
end
it 'allows empty regex pattern from string' do
inspect_source(cop, "'abc'.#{method}(Regexp.new(''), '1')")
expect(cop.messages).to be_empty
end
it 'allows empty regex pattern from regex' do
inspect_source(cop, "'abc'.#{method}(Regexp.new(//), '1')")
expect(cop.messages).to be_empty
end
it 'allows regex literals with options' do
inspect_source(cop, "'abc'.#{method}(/a/i, '1')")
expect(cop.messages).to be_empty
end
it 'allows regex with options' do
inspect_source(cop, "'abc'.#{method}(Regexp.new(/a/i), '1')")
expect(cop.messages).to be_empty
end
it 'allows empty string pattern' do
inspect_source(cop, "'abc'.#{method}('', '1')")
expect(cop.messages).to be_empty
end
end
it 'accepts calls to gsub when the length of the pattern is shorter than ' \
'the length of the replacement' do
inspect_source(cop, "'abc'.#{method}('a', 'ab')")
expect(cop.messages).to be_empty
end
it 'accepts calls to gsub when the length of the pattern is longer than ' \
'the length of the replacement' do
inspect_source(cop, "'abc'.#{method}('ab', 'd')")
expect(cop.messages).to be_empty
end
end
it_behaves_like('accepts', 'gsub')
it_behaves_like('accepts', 'gsub!')
describe 'deterministic regex' do
describe 'regex literal' do
it 'registers an offense when using space' do
inspect_source(cop, %('abc'.gsub(/ /, '')))
expect(cop.messages).to eq(['Use `delete` instead of `gsub`.'])
end
%w[a b c ' " % ! = < > # & ; : ` ~ 1 2 3 - _ , \r \\\\ \y \u1234
\x65].each do |str|
it "registers an offense when replacing #{str} with a literal" do
inspect_source(cop, "'abc'.gsub(/#{str}/, 'a')")
expect(cop.messages).to eq(['Use `tr` instead of `gsub`.'])
end
it "registers an offense when deleting #{str}" do
inspect_source(cop, "'abc'.gsub(/#{str}/, '')")
expect(cop.messages).to eq(['Use `delete` instead of `gsub`.'])
end
end
it 'allows deterministic regex when the length of the pattern ' \
'and the length of the replacement do not match' do
inspect_source(cop, %('abc'.gsub(/a/, 'def')))
expect(cop.messages).to be_empty
end
it 'registers an offense when escape characters in regex' do
inspect_source(cop, %('abc'.gsub(/\n/, ',')))
expect(cop.messages).to eq(['Use `tr` instead of `gsub`.'])
end
it 'registers an offense when using %r notation' do
inspect_source(cop, %('/abc'.gsub(%r{a}, 'd')))
expect(cop.messages).to eq(['Use `tr` instead of `gsub`.'])
end
end
describe 'regex constructor' do
it 'registers an offense when only using word characters' do
inspect_source(cop, "'abc'.gsub(Regexp.new('b'), '2')")
expect(cop.messages).to eq(['Use `tr` instead of `gsub`.'])
end
it 'registers an offense when regex is built from regex' do
inspect_source(cop, "'abc'.gsub(Regexp.new(/b/), '2')")
expect(cop.messages).to eq(['Use `tr` instead of `gsub`.'])
end
it 'registers an offense when using compile' do
inspect_source(cop, "'123'.gsub(Regexp.compile('1'), 'a')")
expect(cop.messages).to eq(['Use `tr` instead of `gsub`.'])
end
end
end
describe 'non deterministic regex' do
it 'allows regex containing a +' do
inspect_source(cop, %('abc'.gsub(/a+/, 'def')))
expect(cop.messages).to be_empty
end
it 'allows regex containing a *' do
inspect_source(cop, %('abc'.gsub(/a*/, 'def')))
expect(cop.messages).to be_empty
end
it 'allows regex containing a ^' do
inspect_source(cop, %('abc'.gsub(/^/, '')))
expect(cop.messages).to be_empty
end
it 'allows regex containing a $' do
inspect_source(cop, %('abc'.gsub(/$/, '')))
expect(cop.messages).to be_empty
end
it 'allows regex containing a ?' do
inspect_source(cop, %('abc'.gsub(/a?/, 'def')))
expect(cop.messages).to be_empty
end
it 'allows regex containing a .' do
inspect_source(cop, %('abc'.gsub(/./, 'a')))
expect(cop.messages).to be_empty
end
it 'allows regex containing a |' do
inspect_source(cop, %('abc'.gsub(/a|b/, 'd')))
expect(cop.messages).to be_empty
end
it 'allows regex containing ()' do
inspect_source(cop, %('abc'.gsub(/(ab)/, 'd')))
expect(cop.messages).to be_empty
end
it 'allows regex containing escaped ()' do
inspect_source(cop, %('(abc)'.gsub(/\(ab\)/, 'd')))
expect(cop.messages).to be_empty
end
it 'allows regex containing {}' do
inspect_source(cop, %('abc'.gsub(/a{3,}/, 'd')))
expect(cop.messages).to be_empty
end
it 'allows regex containing []' do
inspect_source(cop, %('abc'.gsub(/[a-z]/, 'd')))
expect(cop.messages).to be_empty
end
it 'allows regex containing a backslash' do
inspect_source(cop, '"abc".gsub(/\s/, "d")')
expect(cop.messages).to be_empty
end
it 'allows regex literal containing interpolations' do
inspect_source(cop, ["foo = 'a'",
'"abc".gsub(/#{foo}/, "d")'])
expect(cop.messages).to be_empty
end
it 'allows regex constructor containing a string with interpolations' do
inspect_source(cop, ["foo = 'a'",
'"abc".gsub(Regexp.new("#{foo}"), "d")'])
expect(cop.messages).to be_empty
end
it 'allows regex constructor containing regex with interpolations' do
inspect_source(cop, ["foo = 'a'",
'"abc".gsub(Regexp.new(/#{foo}/), "d")'])
expect(cop.messages).to be_empty
end
end
it 'registers an offense when the pattern has non deterministic regex ' \
'as a string' do
inspect_source(cop, %('a + c'.gsub('+', '-')))
expect(cop.messages).to eq(['Use `tr` instead of `gsub`.'])
end
it 'registers an offense when using gsub to find and replace ' \
'a single character' do
inspect_source(cop, "'abc'.gsub('a', '1')")
expect(cop.messages).to eq(['Use `tr` instead of `gsub`.'])
expect(cop.highlights).to eq(["gsub('a', '1')"])
end
it 'registers an offense when using gsub! to find and replace ' \
'a single character ' do
inspect_source(cop, "'abc'.gsub!('a', '1')")
expect(cop.messages).to eq(['Use `tr!` instead of `gsub!`.'])
expect(cop.highlights).to eq(["gsub!('a', '1')"])
end
it 'registers an offense for gsub! when deleting one characters' do
inspect_source(cop, "'abc'.gsub!('a', '')")
expect(cop.messages).to eq(['Use `delete!` instead of `gsub!`.'])
expect(cop.highlights).to eq(["gsub!('a', '')"])
end
it 'registers an offense when using escape characters in the replacement' do
inspect_source(cop, "'abc'.gsub('a', '\n')")
expect(cop.messages).to eq(['Use `tr` instead of `gsub`.'])
end
it 'registers an offense when using escape characters in the pattern' do
inspect_source(cop, "'abc'.gsub('\n', ',')")
expect(cop.messages).to eq(['Use `tr` instead of `gsub`.'])
end
context 'auto-correct' do
describe 'corrects to tr' do
it 'corrects when the length of the pattern and replacement are one' do
new_source = autocorrect_source(cop, "'abc'.gsub('a', 'd')")
expect(new_source).to eq("'abc'.tr('a', 'd')")
end
it 'corrects when the pattern is a regex literal' do
new_source = autocorrect_source(cop, "'abc'.gsub(/a/, '1')")
expect(new_source).to eq("'abc'.tr('a', '1')")
end
it 'corrects when the pattern is a regex literal using %r' do
new_source = autocorrect_source(cop, "'abc'.gsub(%r{a}, '1')")
expect(new_source).to eq("'abc'.tr('a', '1')")
end
it 'corrects when the pattern uses Regexp.new' do
new_source = autocorrect_source(cop,
"'abc'.gsub(Regexp.new('a'), '1')")
expect(new_source).to eq("'abc'.tr('a', '1')")
end
it 'corrects when the pattern uses Regexp.compile' do
new_source = autocorrect_source(cop,
"'abc'.gsub(Regexp.compile('a'), '1')")
expect(new_source).to eq("'abc'.tr('a', '1')")
end
it 'corrects when the replacement contains a new line character' do
new_source = autocorrect_source(cop, "'abc'.gsub('a', '\n')")
expect(new_source).to eq("'abc'.tr('a', '\n')")
end
it 'corrects when the replacement contains escape backslash' do
new_source = autocorrect_source(cop, "\"\".gsub('/', '\\\\')")
expect(new_source).to eq("\"\".tr('/', '\\\\')")
end
it 'corrects when the pattern contains a new line character' do
new_source = autocorrect_source(cop, "'abc'.gsub('\n', ',')")
expect(new_source).to eq("'abc'.tr('\n', ',')")
end
it 'corrects when the pattern contains double backslash' do
new_source = autocorrect_source(cop, "''.gsub('\\\\', '')")
expect(new_source).to eq("''.delete('\\\\')")
end
it 'corrects when replacing to a single quote' do
new_source = autocorrect_source(cop, '"a`b".gsub("`", "\'")')
expect(new_source).to eq('"a`b".tr("`", "\'")')
end
it 'corrects when replacing to a double quote' do
new_source = autocorrect_source(cop, '"a`b".gsub("`", "\"")')
expect(new_source).to eq('"a`b".tr("`", "\"")')
end
end
describe 'corrects to delete' do
it 'corrects when deleting a single character' do
new_source = autocorrect_source(cop, "'abc'.gsub!('a', '')")
expect(new_source).to eq("'abc'.delete!('a')")
end
it 'corrects when the pattern is a regex literal' do
new_source = autocorrect_source(cop, "'abc'.gsub(/a/, '')")
expect(new_source).to eq("'abc'.delete('a')")
end
it 'corrects when deleting an escape character' do
new_source = autocorrect_source(cop, "'abc'.gsub('\n', '')")
expect(new_source).to eq("'abc'.delete('\n')")
end
it 'corrects when the pattern uses Regexp.new' do
new_source = autocorrect_source(cop, "'abc'.gsub(Regexp.new('a'), '')")
expect(new_source).to eq("'abc'.delete('a')")
end
it 'corrects when the pattern uses Regexp.compile' do
new_source = autocorrect_source(cop,
"'ab'.gsub(Regexp.compile('a'), '')")
expect(new_source).to eq("'ab'.delete('a')")
end
it 'corrects when there are no brackets' do
new_source = autocorrect_source(cop, "'abc'.gsub! 'a', ''")
expect(new_source).to eq("'abc'.delete! 'a'")
end
it 'corrects when a regexp contains escapes' do
new_source = autocorrect_source(cop, "'abc'.gsub(/\\n/, '')")
expect(new_source).to eq(%('abc'.delete("\\n")))
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/performance/times_map_spec.rb 0000664 0000000 0000000 00000003604 13070542236 0026142 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Performance::TimesMap do
subject(:cop) { described_class.new }
before do
inspect_source(cop, source)
end
shared_examples 'map_or_collect' do |method|
context ".times.#{method}" do
context 'with a block' do
let(:source) { "4.times.#{method} { |i| i.to_s }" }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(
"Use `Array.new` with a block instead of `.times.#{method}`."
)
expect(cop.highlights).to eq(["4.times.#{method} { |i| i.to_s }"])
end
it 'auto-corrects' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq('Array.new(4) { |i| i.to_s }')
end
end
context 'with an explicitly passed block' do
let(:source) { "4.times.#{method}(&method(:foo))" }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(
"Use `Array.new` with a block instead of `.times.#{method}`."
)
expect(cop.highlights).to eq(["4.times.#{method}(&method(:foo))"])
end
it 'auto-corrects' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq('Array.new(4, &method(:foo))')
end
end
context 'without a block' do
let(:source) { "4.times.#{method}" }
it "doesn't register an offense" do
expect(cop.offenses).to be_empty
end
end
context 'called on nothing' do
let(:source) { "times.#{method} { |i| i.to_s }" }
it "doesn't register an offense" do
expect(cop.offenses).to be_empty
end
end
end
end
it_behaves_like 'map_or_collect', 'map'
it_behaves_like 'map_or_collect', 'collect'
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/ 0000775 0000000 0000000 00000000000 13070542236 0021433 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/action_filter_spec.rb 0000664 0000000 0000000 00000014324 13070542236 0025620 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::ActionFilter, :config do
describe '::FILTER_METHODS' do
it 'contains all of the filter methods' do
expect(described_class::FILTER_METHODS).to eq(%i[
after_filter
append_after_filter
append_around_filter
append_before_filter
around_filter
before_filter
prepend_after_filter
prepend_around_filter
prepend_before_filter
skip_after_filter
skip_around_filter
skip_before_filter
skip_filter
])
end
end
describe '::ACTION_METHODS' do
it 'contains all of the action methods' do
expect(described_class::ACTION_METHODS).to eq(%i[
after_action
append_after_action
append_around_action
append_before_action
around_action
before_action
prepend_after_action
prepend_around_action
prepend_before_action
skip_after_action
skip_around_action
skip_before_action
skip_action_callback
])
end
end
context 'Rails <= 4.0', :rails3 do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'Include' => nil } }
context 'when using action methods' do
described_class::FILTER_METHODS.each do |method|
it "does not register an offense for #{method}" do
inspect_source_file(cop, "#{method} :name")
expect(cop.offenses.size).to eq(0)
end
it "does not register an offense for #{method} with block" do
inspect_source_file(cop, "#{method} { |controller| something }")
expect(cop.offenses.size).to eq(0)
end
end
described_class::ACTION_METHODS.each do |method|
it "accepts #{method}" do
inspect_source_file(cop, "#{method} :something")
expect(cop.offenses).to be_empty
end
end
it 'does not auto-correct to preferred method' do
new_source = autocorrect_source_file(cop, 'before_filter :test')
expect(new_source).to eq('before_filter :test')
end
end
context 'when using filter methods' do
described_class::ACTION_METHODS.each do |method|
it "does not register an offense for #{method}" do
inspect_source_file(cop, "#{method} :name")
expect(cop.offenses.size).to eq(0)
end
it "does not register an offense for #{method} with block" do
inspect_source_file(cop, "#{method} { |controller| something }")
expect(cop.offenses.size).to eq(0)
end
end
described_class::FILTER_METHODS.each do |method|
it "accepts #{method}" do
inspect_source_file(cop, "#{method} :something")
expect(cop.offenses).to be_empty
end
end
it 'does not auto-correct to preferred method' do
new_source = autocorrect_source_file(cop, 'before_action :test')
expect(new_source).to eq('before_action :test')
end
end
end
context 'Rails >= 4.0', :rails4 do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'Include' => nil } }
context 'when style is action' do
before do
cop_config['EnforcedStyle'] = 'action'
end
described_class::FILTER_METHODS.each do |method|
it "registers an offense for #{method}" do
inspect_source_file(cop, "#{method} :name")
expect(cop.offenses.size).to eq(1)
end
it "registers an offense for #{method} with block" do
inspect_source_file(cop, "#{method} { |controller| something }")
expect(cop.offenses.size).to eq(1)
end
end
described_class::ACTION_METHODS.each do |method|
it "accepts #{method}" do
inspect_source_file(cop, "#{method} :something")
expect(cop.offenses).to be_empty
end
end
it 'auto-corrects to preferred method' do
new_source = autocorrect_source_file(cop, 'before_filter :test')
expect(new_source).to eq('before_action :test')
end
end
context 'when style is filter' do
before do
cop_config['EnforcedStyle'] = 'filter'
end
described_class::ACTION_METHODS.each do |method|
it "registers an offense for #{method}" do
inspect_source_file(cop, "#{method} :name")
expect(cop.offenses.size).to eq(1)
end
it "registers an offense for #{method} with block" do
inspect_source_file(cop, "#{method} { |controller| something }")
expect(cop.offenses.size).to eq(1)
end
end
described_class::FILTER_METHODS.each do |method|
it "accepts #{method}" do
inspect_source_file(cop, "#{method} :something")
expect(cop.offenses).to be_empty
end
end
it 'auto-corrects to preferred method' do
new_source = autocorrect_source_file(cop, 'before_action :test')
expect(new_source).to eq('before_filter :test')
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/active_support_aliases_spec.rb 0000664 0000000 0000000 00000005636 13070542236 0027554 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'spec_helper'
describe RuboCop::Cop::Rails::ActiveSupportAliases do
subject(:cop) { described_class.new }
describe 'String' do
describe '#starts_with?' do
it 'is registered as an offence' do
inspect_source(cop, "'some_string'.starts_with?('prefix')")
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `start_with?` instead of `starts_with?`.'])
end
it 'is autocorrected' do
new_source = autocorrect_source(
cop, "'some_string'.starts_with?('prefix')"
)
expect(new_source).to eq "'some_string'.start_with?('prefix')"
end
end
describe '#start_with?' do
it 'is not registered as an offense' do
inspect_source(cop, "'some_string'.start_with?('prefix')")
expect(cop.offenses.size).to eq(0)
end
end
describe '#ends_with?' do
it 'it is registered as an offense' do
inspect_source(cop, "'some_string'.ends_with?('prefix')")
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `end_with?` instead of `ends_with?`.'])
end
it 'is autocorrected' do
new_source = autocorrect_source(
cop, "'some_string'.ends_with?('prefix')"
)
expect(new_source).to eq "'some_string'.end_with?('prefix')"
end
end
describe '#end_with?' do
it 'is not registered as an offense' do
inspect_source(cop, "'some_string'.end_with?('prefix')")
expect(cop.offenses.size).to eq(0)
end
end
end
describe 'Array' do
describe '#append' do
it 'is registered as an offence' do
inspect_source(cop, "[1, 'a', 3].append('element')")
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `<<` instead of `append`.'])
end
it 'is not autocorrected' do
source = "[1, 'a', 3].append('element')"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq source
end
end
describe '#<<' do
it 'is not registered as an offense' do
inspect_source(cop, "[1, 'a', 3] << 'element'")
expect(cop.offenses.size).to eq(0)
end
end
describe '#prepend' do
it 'is registered as an offence' do
inspect_source(cop, "[1, 'a', 3].prepend('element')")
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `unshift` instead of `prepend`.'])
end
it 'is autocorrected' do
new_source = autocorrect_source(
cop, "[1, 'a', 3].prepend('element')"
)
expect(new_source).to eq "[1, 'a', 3].unshift('element')"
end
end
describe '#unshift' do
it 'is not registered as an offense' do
inspect_source(cop, "[1, 'a', 3].unshift('element')")
expect(cop.offenses.size).to eq(0)
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/blank_spec.rb 0000664 0000000 0000000 00000021501 13070542236 0024060 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::Blank, :config do
subject(:cop) { described_class.new(config) }
shared_examples :offense do |source, correction, message|
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq([message])
expect(cop.highlights).to eq([source])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(correction)
end
end
context 'NilOrEmpty set to true' do
let(:cop_config) do
{ 'NilOrEmpty' => true }
end
it 'accepts checking nil?' do
inspect_source(cop, 'foo.nil?')
expect(cop.offenses).to be_empty
end
it 'accepts checking empty?' do
inspect_source(cop, 'foo.empty?')
expect(cop.offenses).to be_empty
end
it 'accepts checking nil? || empty? on different objects' do
inspect_source(cop, 'foo.nil? || bar.empty?')
expect(cop.offenses).to be_empty
end
# Bug: https://github.com/bbatsov/rubocop/issues/4171
it 'does not break when RHS of `or` is a naked falsiness check' do
inspect_source(cop, 'foo.empty? || bar')
expect(cop.offenses).to be_empty
end
it 'does not break when LHS of `or` is a naked falsiness check' do
inspect_source(cop, 'bar || foo.empty?')
expect(cop.offenses).to be_empty
end
context 'nil or empty' do
it_behaves_like :offense, 'foo.nil? || foo.empty?',
'foo.blank?',
'Use `foo.blank?` instead of `foo.nil? || foo.empty?`.'
it_behaves_like :offense, 'foo == nil || foo.empty?',
'foo.blank?',
'Use `foo.blank?` instead of `foo == nil || foo.empty?`.'
it_behaves_like :offense, 'nil == foo || foo.empty?',
'foo.blank?',
'Use `foo.blank?` instead of `nil == foo || foo.empty?`.'
it_behaves_like :offense, '!foo || foo.empty?',
'foo.blank?',
'Use `foo.blank?` instead of `!foo || foo.empty?`.'
it_behaves_like :offense, 'foo.nil? || !!foo.empty?',
'foo.blank?',
'Use `foo.blank?` instead of `foo.nil? || !!foo.empty?`.'
it_behaves_like :offense, 'foo == nil || !!foo.empty?',
'foo.blank?',
'Use `foo.blank?` instead of ' \
'`foo == nil || !!foo.empty?`.'
it_behaves_like :offense, 'nil == foo || !!foo.empty?',
'foo.blank?',
'Use `foo.blank?` instead of ' \
'`nil == foo || !!foo.empty?`.'
end
context 'checking all variable types' do
it_behaves_like :offense, 'foo.bar.nil? || foo.bar.empty?',
'foo.bar.blank?',
'Use `foo.bar.blank?` instead of ' \
'`foo.bar.nil? || foo.bar.empty?`.'
it_behaves_like :offense, 'FOO.nil? || FOO.empty?',
'FOO.blank?',
'Use `FOO.blank?` instead of `FOO.nil? || FOO.empty?`.'
it_behaves_like :offense, 'Foo.nil? || Foo.empty?',
'Foo.blank?',
'Use `Foo.blank?` instead of `Foo.nil? || Foo.empty?`.'
it_behaves_like :offense, 'Foo::Bar.nil? || Foo::Bar.empty?',
'Foo::Bar.blank?',
'Use `Foo::Bar.blank?` instead of ' \
'`Foo::Bar.nil? || Foo::Bar.empty?`.'
it_behaves_like :offense, '@foo.nil? || @foo.empty?',
'@foo.blank?',
'Use `@foo.blank?` instead of `@foo.nil? || @foo.empty?`.'
it_behaves_like :offense, '$foo.nil? || $foo.empty?',
'$foo.blank?',
'Use `$foo.blank?` instead of `$foo.nil? || $foo.empty?`.'
it_behaves_like :offense, '@@foo.nil? || @@foo.empty?',
'@@foo.blank?',
'Use `@@foo.blank?` instead of ' \
'`@@foo.nil? || @@foo.empty?`.'
it_behaves_like :offense, 'foo[bar].nil? || foo[bar].empty?',
'foo[bar].blank?',
'Use `foo[bar].blank?` instead of ' \
'`foo[bar].nil? || foo[bar].empty?`.'
it_behaves_like :offense, 'foo(bar).nil? || foo(bar).empty?',
'foo(bar).blank?',
'Use `foo(bar).blank?` instead of ' \
'`foo(bar).nil? || foo(bar).empty?`.'
end
end
context 'NotPresent set to true' do
let(:cop_config) do
{ 'NotPresent' => true }
end
it_behaves_like :offense, '!foo.present?',
'foo.blank?',
'Use `foo.blank?` instead of `!foo.present?`.'
it_behaves_like :offense, 'not foo.present?',
'foo.blank?',
'Use `foo.blank?` instead of `not foo.present?`.'
end
context 'UnlessPresent set to true' do
let(:cop_config) do
{ 'UnlessPresent' => true }
end
it 'accepts modifier if present?' do
inspect_source(cop, 'something if foo.present?')
expect(cop.offenses).to be_empty
end
it 'accepts modifier unless blank?' do
inspect_source(cop, 'something unless foo.blank?')
expect(cop.offenses).to be_empty
end
it 'accepts normal if present?' do
inspect_source(cop, ['if foo.present?',
' something',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts normal unless blank?' do
inspect_source(cop, ['unless foo.blank?',
' something',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts elsif present?' do
inspect_source(cop, ['if bar.present?',
' something',
'elsif bar.present?',
' something_else',
'end'])
expect(cop.offenses).to be_empty
end
context 'modifier unless' do
let(:source) { 'something unless foo.present?' }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages)
.to eq(['Use `if foo.blank?` instead of `unless foo.present?`.'])
expect(cop.highlights).to eq(['unless foo.present?'])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('something if foo.blank?')
end
end
context 'normal unless present?' do
let(:source) do
['unless foo.present?',
' something',
'end']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages)
.to eq(['Use `if foo.blank?` instead of `unless foo.present?`.'])
expect(cop.highlights).to eq(['unless foo.present?'])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['if foo.blank?',
' something',
'end'].join("\n"))
end
end
context 'unless present? with an else' do
let(:source) do
['unless foo.present?',
' something',
'else',
' something_else',
'end']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages)
.to eq(['Use `if foo.blank?` instead of `unless foo.present?`.'])
expect(cop.highlights).to eq(['unless foo.present?'])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['if foo.blank?',
' something',
'else',
' something_else',
'end'].join("\n"))
end
end
end
context 'NilOrEmpty set to false' do
let(:cop_config) do
{ 'NilOrEmpty' => false,
'NotPresent' => true,
'UnlessPresent' => true }
end
it 'accepts checking nil? || empty?' do
inspect_source(cop, 'foo.nil? || foo.empty?')
expect(cop.offenses).to be_empty
end
end
context 'NotPresent set to false' do
let(:cop_config) do
{ 'NilOrEmpty' => true,
'NotPresent' => false,
'UnlessPresent' => true }
end
it 'accepts !present?' do
inspect_source(cop, '!foo.present?')
expect(cop.offenses).to be_empty
end
end
context 'UnlessPresent set to false' do
let(:cop_config) do
{ 'NilOrEmpty' => true,
'NotPresent' => true,
'UnlessPresent' => false }
end
it 'accepts unless present?' do
inspect_source(cop, 'something unless foo.present?')
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/date_spec.rb 0000664 0000000 0000000 00000006074 13070542236 0023716 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::Date, :config do
subject(:cop) { described_class.new(config) }
context 'when EnforcedStyle is "strict"' do
let(:cop_config) { { 'EnforcedStyle' => 'strict' } }
%w[today current yesterday tomorrow].each do |day|
it "registers an offense for Date.#{day}" do
inspect_source(cop, "Date.#{day}")
expect(cop.offenses.size).to eq(1)
end
it "registers an offense for ::Date.#{day}" do
inspect_source(cop, "::Date.#{day}")
expect(cop.offenses.size).to eq(1)
end
it "accepts Some::Date.#{day}" do
inspect_source(cop, "Some::Date.#{day}")
expect(cop.offenses).to be_empty
end
end
%w[to_time to_time_in_current_zone].each do |method|
it "registers an offense for ##{method}" do
inspect_source(cop, "date.#{method}")
expect(cop.offenses.size).to eq(1)
end
it "accepts variable named #{method}" do
inspect_source(cop, "#{method} = 1")
expect(cop.offenses).to be_empty
end
it "accepts variable #{method} as range end" do
inspect_source(cop, "from_time..#{method}")
expect(cop.offenses).to be_empty
end
end
context 'when a zone is provided' do
it 'does not register an offense' do
inspect_source(cop, 'date.to_time(:utc)')
expect(cop.offenses).to be_empty
end
end
context 'when a string literal with timezone' do
it 'does not register an offense' do
inspect_source(cop, '"2016-07-12 14:36:31 +0100".to_time(:utc)')
expect(cop.offenses).to be_empty
end
end
context 'when a string literal without timezone' do
it 'registers an offense' do
inspect_source(cop, '"2016-07-12 14:36:31".to_time(:utc)')
expect(cop.offenses.size).to eq(1)
end
end
it 'does not blow up in the presence of a single constant to inspect' do
inspect_source(cop, 'A')
expect(cop.offenses).to be_empty
end
RuboCop::Cop::Rails::TimeZone::ACCEPTED_METHODS.each do |a_method|
it "registers an offense for val.to_time.#{a_method}" do
inspect_source(cop, "val.to_time.#{a_method}")
expect(cop.offenses.size).to eq(1)
end
end
end
context 'when EnforcedStyle is "flexible"' do
let(:cop_config) { { 'EnforcedStyle' => 'flexible' } }
%w[current yesterday tomorrow].each do |day|
it "accepts Date.#{day}" do
inspect_source(cop, "Date.#{day}")
expect(cop.offenses).to be_empty
end
end
it 'registers an offense for Date.today' do
inspect_source(cop, 'Date.today')
expect(cop.offenses.size).to eq(1)
end
RuboCop::Cop::Rails::TimeZone::ACCEPTED_METHODS.each do |a_method|
it "accepts val.to_time.#{a_method}" do
inspect_source(cop, "val.to_time.#{a_method}")
expect(cop.offenses).to be_empty
end
end
it 'accepts #to_time_in_current_zone' do
inspect_source(cop, 'date.to_time_in_current_zone')
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/delegate_allow_blank_spec.rb 0000664 0000000 0000000 00000001647 13070542236 0027121 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::DelegateAllowBlank do
subject(:cop) { described_class.new }
it 'registers an offense when using allow_blank' do
inspect_source(cop, 'delegate :foo, to: :bar, allow_blank: true')
msg = '`allow_blank` is not a valid option, use `allow_nil`.'
expect(cop.messages).to eq([msg])
end
it 'does not register an offense when using allow_nil' do
inspect_source(cop, 'delegate :foo, to: :bar, allow_nil: true')
expect(cop.messages).to be_empty
end
it 'does not register an offense when no extra options given' do
inspect_source(cop, 'delegate :foo, to: :bar')
expect(cop.messages).to be_empty
end
it 'autocorrects allow_blank to allow_nil' do
source = 'delegate :foo, to: :bar, allow_blank: true'
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('delegate :foo, to: :bar, allow_nil: true')
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/delegate_spec.rb 0000664 0000000 0000000 00000011360 13070542236 0024545 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::Delegate do
subject(:cop) { described_class.new }
it 'finds trivial delegate' do
inspect_source(cop,
['def foo',
' bar.foo',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.offenses
.map(&:line).sort).to eq([1])
expect(cop.messages)
.to eq(['Use `delegate` to define delegations.'])
expect(cop.highlights).to eq(['def'])
end
it 'finds trivial delegate with arguments' do
inspect_source(cop,
['def foo(baz)',
' bar.foo(baz)',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.offenses
.map(&:line).sort).to eq([1])
expect(cop.messages)
.to eq(['Use `delegate` to define delegations.'])
expect(cop.highlights).to eq(['def'])
end
it 'finds trivial delegate with prefix' do
inspect_source(cop,
['def bar_foo',
' bar.foo',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.offenses
.map(&:line).sort).to eq([1])
expect(cop.messages)
.to eq(['Use `delegate` to define delegations.'])
expect(cop.highlights).to eq(['def'])
end
it 'ignores class methods' do
inspect_source(cop,
['def self.fox',
' new.fox',
'end'])
expect(cop.offenses).to be_empty
end
it 'ignores non trivial delegate' do
inspect_source(cop,
['def fox',
' bar.foo.fox',
'end'])
expect(cop.offenses).to be_empty
end
it 'ignores trivial delegate with mismatched arguments' do
inspect_source(cop,
['def fox(baz)',
' bar.fox(foo)',
'end'])
expect(cop.offenses).to be_empty
end
it 'ignores trivial delegate with optional argument with a default value' do
inspect_source(cop,
['def fox(foo = nil)',
' bar.fox(foo || 5)',
'end'])
expect(cop.offenses).to be_empty
end
it 'ignores trivial delegate with mismatched number of arguments' do
inspect_source(cop,
['def fox(a, baz)',
' bar.fox(a)',
'end'])
expect(cop.offenses).to be_empty
end
it 'ignores trivial delegate with other prefix' do
inspect_source(cop,
['def fox_foo',
' bar.foo',
'end'])
expect(cop.offenses).to be_empty
end
it 'ignores methods with arguments' do
inspect_source(cop,
['def fox(bar)',
' bar.fox',
'end'])
expect(cop.offenses).to be_empty
end
it 'ignores private delegations' do
inspect_source(cop,
[' private def fox', # leading spaces are on purpose
' bar.fox',
' end',
' ',
' private',
' ',
' def fox',
' bar.fox',
' end'])
expect(cop.offenses).to be_empty
end
it 'ignores protected delegations' do
inspect_source(cop,
[' protected def fox', # leading spaces are on purpose
' bar.fox',
' end',
' ',
' protected',
' ',
' def fox',
' bar.fox',
' end'])
expect(cop.offenses).to be_empty
end
it 'ignores delegation with assignment' do
inspect_source(cop,
['def new',
' @bar = Foo.new',
'end'])
expect(cop.offenses).to be_empty
end
it 'ignores delegation to constant' do
inspect_source(cop,
['FOO = []',
'def size',
' FOO.size',
'end'])
expect(cop.offenses).to be_empty
end
describe '#autocorrect' do
context 'trivial delegation' do
let(:source) do
['def bar',
' foo.bar',
'end']
end
let(:corrected_source) { 'delegate :bar, to: :foo' }
it 'autocorrects' do
expect(autocorrect_source(cop, source)).to eq(corrected_source)
end
end
context 'trivial delegation with prefix' do
let(:source) do
['def foo_bar',
' foo.bar',
'end']
end
let(:corrected_source) { 'delegate :bar, to: :foo, prefix: true' }
it 'autocorrects' do
expect(autocorrect_source(cop, source)).to eq(corrected_source)
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/dynamic_find_by_spec.rb 0000664 0000000 0000000 00000007454 13070542236 0026122 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::DynamicFindBy, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) do
{ 'Whitelist' => %w[find_by_sql] }
end
shared_examples 'register an offense and auto correct' do |message, corrected|
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq([message])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(corrected)
end
end
context 'with dynamic find_by_*' do
let(:source) { 'User.find_by_name(name)' }
include_examples(
'register an offense and auto correct',
'Use `find_by` instead of dynamic `find_by_name`.',
'User.find_by(name: name)'
)
end
context 'with dynamic find_by_*_and_*' do
let(:source) { 'User.find_by_name_and_email(name, email)' }
include_examples(
'register an offense and auto correct',
'Use `find_by` instead of dynamic `find_by_name_and_email`.',
'User.find_by(name: name, email: email)'
)
end
context 'with dynamic find_by_*!' do
let(:source) { 'User.find_by_name!(name)' }
include_examples(
'register an offense and auto correct',
'Use `find_by!` instead of dynamic `find_by_name!`.',
'User.find_by!(name: name)'
)
end
context 'with dynamic find_by_*_and_*_and_*' do
let(:source) { 'User.find_by_name_and_email_and_token(name, email, token)' }
include_examples(
'register an offense and auto correct',
'Use `find_by` instead of dynamic `find_by_name_and_email_and_token`.',
'User.find_by(name: name, email: email, token: token)'
)
end
context 'with dynamic find_by_*_and_*_and_*!' do
let(:source) do
'User.find_by_name_and_email_and_token!(name, email, token)'
end
include_examples(
'register an offense and auto correct',
'Use `find_by!` instead of dynamic `find_by_name_and_email_and_token!`.',
'User.find_by!(name: name, email: email, token: token)'
)
end
context 'with dynamic find_by_*_and_*_and_* with newline' do
let(:source) do
[
'User.find_by_name_and_email_and_token(',
' name,',
' email,',
' token',
')'
]
end
include_examples(
'register an offense and auto correct',
'Use `find_by` instead of dynamic `find_by_name_and_email_and_token`.',
"User.find_by(\n" \
" name: name,\n" \
" email: email,\n" \
" token: token\n" \
')' \
)
end
context 'with column includes undersoce' do
let(:source) { 'User.find_by_first_name(name)' }
include_examples(
'register an offense and auto correct',
'Use `find_by` instead of dynamic `find_by_first_name`.',
'User.find_by(first_name: name)'
)
end
context 'with too much arguments' do
let(:source) { 'User.find_by_name_and_email(name, email, token)' }
include_examples(
'register an offense and auto correct',
'Use `find_by` instead of dynamic `find_by_name_and_email`.',
# Do not correct
'User.find_by_name_and_email(name, email, token)'
)
end
context 'with too few arguments' do
let(:source) { 'User.find_by_name_and_email(name)' }
include_examples(
'register an offense and auto correct',
'Use `find_by` instead of dynamic `find_by_name_and_email`.',
# Do not correct
'User.find_by_name_and_email(name)'
)
end
it 'accepts' do
inspect_source(cop, 'User.find_by(name: name)')
expect(cop.offenses).to be_empty
end
it 'accepts method in whitelist' do
source = 'User.find_by_sql(["select * from users where name = ?", name])'
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/enum_uniqueness_spec.rb 0000664 0000000 0000000 00000005377 13070542236 0026231 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::EnumUniqueness, :config do
subject(:cop) { described_class.new }
context 'when array syntax is used' do
context 'with a single duplicated enum value' do
it 'registers an offense' do
inspect_source(cop, 'enum status: [:active, :archived, :active]')
msg = 'Duplicate value `:active` found in `status` enum declaration.'
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq([msg])
end
end
context 'with several duplicated enum values' do
it 'registers two offenses' do
inspect_source(cop,
'enum status: [:active, :archived, :active, :active]')
expect(cop.offenses.size).to eq(2)
end
end
context 'with no duplicated enum values' do
it 'does not register an offense for unique enum values' do
inspect_source(cop, 'enum status: [:active, :archived]')
expect(cop.offenses).to be_empty
end
end
end
context 'when hash syntax is used' do
context 'with a single duplicated enum value' do
it 'registers an offense' do
inspect_source(cop, 'enum status: { active: 0, archived: 0 }')
msg = 'Duplicate value `0` found in `status` enum declaration.'
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq([msg])
end
end
context 'with several duplicated enum values' do
it 'registers two offenses' do
inspect_source(cop,
'enum status: { active: 0, pending: 0, archived: 0 }')
expect(cop.offenses.size).to eq(2)
end
end
context 'with no duplicated enum values' do
it 'does not register an offense' do
inspect_source(cop, 'enum status: { active: 0, pending: 1 }')
expect(cop.offenses).to be_empty
end
end
end
context 'when receiving a variable' do
it 'does not register an offense' do
inspect_source(cop, ['var = { status: { active: 0, archived: 1 } }',
'enum var'])
expect(cop.offenses).to be_empty
end
end
context 'when receiving a hash without literal values' do
context 'when value is a variable' do
it 'does not register an offense' do
inspect_source(cop, 'enum status: statuses')
expect(cop.offenses).to be_empty
end
end
context 'when value is a method chain' do
it 'does not register an offense' do
inspect_source(cop, 'enum status: User.statuses.keys')
expect(cop.offenses).to be_empty
end
end
context 'when value is a constant' do
it 'does not register an offense' do
inspect_source(cop, 'enum status: STATUSES')
expect(cop.offenses).to be_empty
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/exit_spec.rb 0000664 0000000 0000000 00000003721 13070542236 0023746 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::Exit, :config do
subject(:cop) { described_class.new }
it 'registers an offense for an exit call with no receiver' do
inspect_source(cop,
'exit')
expect(cop.messages).to eq([RuboCop::Cop::Rails::Exit::MSG])
end
it 'registers an offense for an exit! call with no receiver' do
inspect_source(cop,
'exit!')
expect(cop.messages).to eq([RuboCop::Cop::Rails::Exit::MSG])
end
context 'exit calls on objects' do
it 'does not register an offense for an explicit exit call on an object' do
inspect_source(cop,
'Object.new.exit')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for an explicit exit call '\
'with an argument on an object' do
inspect_source(cop,
'Object.new.exit(0)')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for an explicit exit! call on an object' do
inspect_source(cop,
'Object.new.exit!(0)')
expect(cop.offenses).to be_empty
end
end
context 'with arguments' do
it 'registers an offense for an exit(0) call with no receiver' do
inspect_source(cop,
'exit(0)')
expect(cop.offenses.size).to eq(1)
end
it 'ignores exit calls with unexpected number of parameters' do
inspect_source(cop,
'exit(1, 2)')
expect(cop.offenses).to be_empty
end
end
context 'explicit calls' do
it 'does register an offense for explicit Kernel.exit calls' do
inspect_source(cop,
'Kernel.exit')
expect(cop.messages).to eq([RuboCop::Cop::Rails::Exit::MSG])
end
it 'does register an offense for explicit Process.exit calls' do
inspect_source(cop,
'Process.exit')
expect(cop.messages).to eq([RuboCop::Cop::Rails::Exit::MSG])
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/file_path_spec.rb 0000664 0000000 0000000 00000003553 13070542236 0024733 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::FilePath do
subject(:cop) { described_class.new }
context 'when using Rails.root.join with some path strings' do
let(:source) { "Rails.root.join('app', 'models', 'user.rb')" }
it 'does not registers an offense' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
context 'when using File.join with Rails.root' do
let(:source) { "File.join(Rails.root, 'app', 'models')" }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
end
context 'when using Rails.root.join with slash separated path string' do
let(:source) { "Rails.root.join('app/models/goober')" }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
end
context 'when using Rails.root called by double quoted string' do
let(:source) { '"#{Rails.root}/app/models/goober"' }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
end
context 'Rails.root is used as a method argument' do
let(:source) { 'foo(bar(File.join(Rails.root, "app", "models")))' }
it 'registers an offense once' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
end
context 'Rails.root.join used as an argument' do
let(:source) { 'foo(Rails.root.join(\'app/models\'))' }
it 'registers an offense once' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
end
context 'Rails.root.join with a non-string argument including "/"' do
let(:source) { 'Rails.root.join("tmp", "data", index/3, "data.csv")' }
it 'does not register an offense' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/find_by_spec.rb 0000664 0000000 0000000 00000001711 13070542236 0024404 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::FindBy do
subject(:cop) { described_class.new }
shared_examples 'registers_offense' do |selector|
it "when using where.#{selector}" do
inspect_source(cop, "User.where(id: x).#{selector}")
expect(cop.messages)
.to eq(["Use `find_by` instead of `where.#{selector}`."])
end
end
it_behaves_like('registers_offense', 'first')
it_behaves_like('registers_offense', 'take')
it 'does not register an offense when using find_by' do
inspect_source(cop, 'User.find_by(id: x)')
expect(cop.messages).to be_empty
end
it 'autocorrects where.take to find_by' do
new_source = autocorrect_source(cop, 'User.where(id: x).take')
expect(new_source).to eq('User.find_by(id: x)')
end
it 'does not autocorrect where.first' do
new_source = autocorrect_source(cop, 'User.where(id: x).first')
expect(new_source).to eq('User.where(id: x).first')
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/find_each_spec.rb 0000664 0000000 0000000 00000003015 13070542236 0024671 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::FindEach do
subject(:cop) { described_class.new }
shared_examples 'register_offense' do |scope|
it "registers an offense when using #{scope}.each" do
inspect_source(cop, "User.#{scope}.each { |u| u.something }")
expect(cop.messages).to eq(['Use `find_each` instead of `each`.'])
end
it "does not register an offense when using #{scope}.order(...).each" do
inspect_source(cop, "User.#{scope}.order(:name).each { |u| u.something }")
expect(cop.offenses).to be_empty
end
it "does not register an offense when using #{scope}.limit(...).each" do
inspect_source(cop, "User.#{scope}.limit(10).each { |u| u.something }")
expect(cop.offenses).to be_empty
end
it "does not register an offense when using #{scope}.select(...).each" do
inspect_source(cop, "User.#{scope}.select(:name, :age).each " \
'{ |u| u.something }')
expect(cop.offenses).to be_empty
end
end
it_behaves_like('register_offense', 'where(name: name)')
it_behaves_like('register_offense', 'all')
it_behaves_like('register_offense', 'where.not(name: name)')
it 'does not register an offense when using find_by' do
inspect_source(cop, 'User.all.find_each { |u| u.x }')
expect(cop.messages).to be_empty
end
it 'auto-corrects each to find_each' do
new_source = autocorrect_source(cop, 'User.all.each { |u| u.x }')
expect(new_source).to eq('User.all.find_each { |u| u.x }')
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/has_and_belongs_to_many_spec.rb 0000664 0000000 0000000 00000000467 13070542236 0027635 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::HasAndBelongsToMany do
subject(:cop) { described_class.new }
it 'registers an offense for has_and_belongs_to_many' do
inspect_source(cop,
'has_and_belongs_to_many :groups')
expect(cop.offenses.size).to eq(1)
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/http_positional_arguments_spec.rb 0000664 0000000 0000000 00000040544 13070542236 0030306 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::HttpPositionalArguments do
context 'rails 4', :rails4, :config do
subject(:cop) { described_class.new(config) }
it 'does not register an offense for post method' do
source = 'post :create, user_id: @user.id'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(0)
end
it 'does not register an offense for patch method' do
source = 'patch :update, user_id: @user.id'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(0)
end
it 'does not register an offense for delete method' do
source = 'delete :destroy, id: @user.id'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(0)
end
it 'accepts for not HTTP method' do
source = 'puts :create, user_id: @user.id'
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
describe 'when using process' do
let(:source) do
'process :new, method: :get, params: { user_id: @user.id }'
end
it 'does not register an offense' do
inspect_source(cop, source)
expect(cop.messages).to be_empty
end
end
[
'params: { user_id: @user.id }',
'xhr: true',
'session: { foo: \'bar\' }',
'format: :json'
].each do |keyword_args|
describe "when using keyword args #{keyword_args}" do
let(:source) do
"get :new, #{keyword_args}"
end
it 'does not register an offense' do
inspect_source(cop, source)
expect(cop.messages).to be_empty
end
end
end
describe '.get' do
let(:source) do
'get :new, user_id: @user.id'
end
it 'does not register an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(0)
end
it 'does not auto-correct' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
describe 'no params' do
let(:source) do
'get :new'
end
it 'does not register an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(0)
end
end
end
describe '.patch' do
let(:source) do
<<-EOS.strip_indent
patch :update,
id: @user.id,
ac: {
article_id: @article1.id,
profile_id: @profile1.id,
content: 'Some Text'
}
EOS
end
it 'does not register an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(0)
end
it 'does not auto-correct' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
end
describe '.post' do
let(:source) do
<<-EOS.strip_indent
post :create,
id: @user.id,
ac: {
article_id: @article1.id,
profile_id: @profile1.id,
content: 'Some Text'
}
EOS
end
it 'does not register an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(0)
end
it 'does not auto-correct' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
end
%w[post get patch put delete].each do |keyword|
it 'does not register an offense when keyword' do
source = "@user.#{keyword}.id = ''"
inspect_source(cop, source)
expect(cop.offenses.size).to eq(0)
end
end
it 'does not auto-correct http action when method' do
source = 'post user_attrs, id: 1'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(0)
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
it 'does not auto-correct http action when symbol' do
source = 'post :user_attrs, id: 1'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(0)
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
it 'does not auto-correct' do
source = 'post(:user_attrs, id: 1)'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(0)
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
it 'does not register when post is found' do
source = "if post.stint_title.present? \n true\n end"
inspect_source(cop, source)
expect(cop.offenses.size).to eq(0)
end
it 'does not remove quotes when single quoted' do
source = "get '/auth/linkedin/callback'"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("get '/auth/linkedin/callback'")
end
it 'does not remove quotes when double quoted' do
source = 'get "/auth/linkedin/callback"'
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('get "/auth/linkedin/callback"')
end
it 'does not add headers keyword when env or headers are used' do
source = 'get some_path(profile.id), {},'
source += " 'HTTP_REFERER' => p_url(p.id).to_s"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
it 'does not duplicate brackets when hash is already supplied' do
source = 'get some_path(profile.id), '
source += '{ user_id: @user.id, profile_id: p.id },'
source += " 'HTTP_REFERER' => p_url(p.id).to_s"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
it 'does not auto-correct http action when params is a method call' do
source = 'post :create, confirmation_data'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(0)
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
# rubocop:disable LineLength
it 'does not auto-correct http action when parameter matches keyword name' do
source = 'post :create, id: 7, comment: { body: "hei" }'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(0)
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
it 'does not auto-correct http action when format keyword included but not alone' do
source = 'post :create, id: 7, format: :rss'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(0)
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
it 'auto-corrects http action when params is a lvar' do
source = [
'params = { id: 1 }',
'post user_attrs, params'
]
inspect_source(cop, source)
expect(cop.offenses.size).to eq(0)
new_source = autocorrect_source(cop, source)
expected = "params = { id: 1 }\npost user_attrs, params"
expect(new_source).to eq(expected)
end
it 'does not auto-correct http action when params is a method call' do
source = 'post user_attrs, params'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(0)
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
it 'does not auto-correct http action when params is a method call with chain' do
source = 'post user_attrs, params.merge(foo: bar)'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(0)
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
end
context 'rails 5 and above', :rails5 do
subject(:cop) { described_class.new }
it 'registers an offense for post method' do
source = 'post :create, user_id: @user.id'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for patch method' do
source = 'patch :update, user_id: @user.id'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for delete method' do
source = 'delete :destroy, id: @user.id'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'accepts for not HTTP method' do
source = 'puts :create, user_id: @user.id'
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
describe 'when using process' do
let(:source) do
'process :new, method: :get, params: { user_id: @user.id }'
end
it 'does not register an offense' do
inspect_source(cop, source)
expect(cop.messages).to be_empty
end
end
[
'params: { user_id: @user.id }',
'xhr: true',
'session: { foo: \'bar\' }',
'format: :json'
].each do |keyword_args|
describe "when using keyword args #{keyword_args}" do
let(:source) do
"get :new, #{keyword_args}"
end
it 'does not register an offense' do
inspect_source(cop, source)
expect(cop.messages).to be_empty
end
end
end
describe '.get' do
let(:source) do
'get :new, user_id: @user.id'
end
let(:corrected_result) do
'get :new, params: { user_id: @user.id }'
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'autocorrects offense' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(corrected_result)
end
describe 'no params' do
let(:source) do
'get :new'
end
it 'does not register an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(0)
end
end
end
describe '.patch' do
let(:source) do
<<-EOS.strip_indent
patch :update,
id: @user.id,
ac: {
article_id: @article1.id,
profile_id: @profile1.id,
content: 'Some Text'
}
EOS
end
let(:corrected_result) do
<<-EOS.strip_indent
patch :update, params: { id: @user.id, ac: {
article_id: @article1.id,
profile_id: @profile1.id,
content: 'Some Text'
} }
EOS
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'autocorrects offense' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(corrected_result)
end
end
describe '.post' do
let(:source) do
<<-EOS.strip_indent
post :create,
id: @user.id,
ac: {
article_id: @article1.id,
profile_id: @profile1.id,
content: 'Some Text'
}
EOS
end
let(:corrected_result) do
<<-EOS.strip_indent
post :create, params: { id: @user.id, ac: {
article_id: @article1.id,
profile_id: @profile1.id,
content: 'Some Text'
} }
EOS
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'autocorrects offense' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(corrected_result)
end
end
%w[post get patch put delete].each do |keyword|
it 'does not register an offense when keyword' do
source = "@user.#{keyword}.id = ''"
inspect_source(cop, source)
expect(cop.offenses.size).to eq(0)
end
end
it 'auto-corrects http action when method' do
source = 'post user_attrs, id: 1'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
new_source = autocorrect_source(cop, source)
expected = 'post user_attrs, params: { id: 1 }'
expect(new_source).to eq(expected)
end
it 'auto-corrects http action when symbol' do
source = 'post :user_attrs, id: 1'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
new_source = autocorrect_source(cop, source)
expected = 'post :user_attrs, params: { id: 1 }'
expect(new_source).to eq(expected)
end
it 'maintains parentheses in auto-correcting' do
source = 'post(:user_attrs, id: 1)'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
new_source = autocorrect_source(cop, source)
expected = 'post(:user_attrs, params: { id: 1 })'
expect(new_source).to eq(expected)
end
it 'does not register when post is found' do
source = "if post.stint_title.present? \n true\n end"
inspect_source(cop, source)
expect(cop.offenses.size).to eq(0)
end
it 'does not remove quotes when single quoted' do
source = "get '/auth/linkedin/callback'"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("get '/auth/linkedin/callback'")
end
it 'does not remove quotes when double quoted' do
source = 'get "/auth/linkedin/callback"'
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('get "/auth/linkedin/callback"')
end
it 'does add headers keyword when env or headers are used' do
source = 'get some_path(profile.id), {},'
source += " 'HTTP_REFERER' => p_url(p.id).to_s"
new_source = autocorrect_source(cop, source)
output = 'get some_path(profile.id),'
output += " headers: { 'HTTP_REFERER' => p_url(p.id).to_s }"
expect(new_source).to eq(output)
end
it 'does not duplicate brackets when hash is already supplied' do
source = 'get some_path(profile.id), '
source += '{ user_id: @user.id, profile_id: p.id },'
source += " 'HTTP_REFERER' => p_url(p.id).to_s"
new_source = autocorrect_source(cop, source)
output = 'get some_path(profile.id), params:'
output += ' { user_id: @user.id, profile_id: p.id },'
output += " headers: { 'HTTP_REFERER' => p_url(p.id).to_s }"
expect(new_source).to eq(output)
end
it 'auto-corrects http action when params is a method call' do
source = 'post :create, confirmation_data'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
new_source = autocorrect_source(cop, source)
output = 'post :create, params: confirmation_data'
expect(new_source).to eq(output)
end
it 'auto-corrects http action when parameter matches special keyword name' do
source = 'post :create, id: 7, comment: { body: "hei" }'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
new_source = autocorrect_source(cop, source)
output = 'post :create, params: { id: 7, comment: { body: "hei" } }'
expect(new_source).to eq(output)
end
it 'auto-corrects http action when format keyword included but not alone' do
source = 'post :create, id: 7, format: :rss'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
new_source = autocorrect_source(cop, source)
output = 'post :create, params: { id: 7, format: :rss }'
expect(new_source).to eq(output)
end
it 'auto-corrects http action when params is a lvar' do
source = [
'params = { id: 1 }',
'post user_attrs, params'
]
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
new_source = autocorrect_source(cop, source)
expected = "params = { id: 1 }\npost user_attrs, params: params"
expect(new_source).to eq(expected)
end
it 'auto-corrects http action when params is a method call' do
source = 'post user_attrs, params'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
new_source = autocorrect_source(cop, source)
expected = 'post user_attrs, params: params'
expect(new_source).to eq(expected)
end
it 'auto-corrects http action when params is a method call with chain' do
source = 'post user_attrs, params.merge(foo: bar)'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
new_source = autocorrect_source(cop, source)
expected = 'post user_attrs, params: params.merge(foo: bar)'
expect(new_source).to eq(expected)
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/not_null_column_spec.rb 0000664 0000000 0000000 00000005261 13070542236 0026205 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::NotNullColumn, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'Include' => nil } }
before do
inspect_source(cop, source)
end
context 'with add_column call' do
context 'with null: false' do
let(:source) { 'add_column :users, :name, :string, null: false' }
it 'reports an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['Do not add a NOT NULL column without a default value.']
)
end
end
context 'with null: false and default' do
let(:source) do
'add_column :users, :name, :string, null: false, default: ""'
end
include_examples 'accepts'
end
context 'with null: false and default: nil' do
let(:source) do
'add_column :users, :name, :string, null: false, default: nil'
end
it 'reports an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['Do not add a NOT NULL column without a default value.']
)
end
end
context 'with null: true' do
let(:source) { 'add_column :users, :name, :string, null: true' }
include_examples 'accepts'
end
context 'without any options' do
let(:source) { 'add_column :users, :name, :string' }
include_examples 'accepts'
end
end
context 'with change_column call' do
let(:source) do
[
'add_column :users, :name, :string',
'User.update_all(name: "dummy")',
'change_column :users, :name, :string, null: false'
]
end
include_examples 'accepts'
end
context 'with create_table call' do
let(:source) do
['class CreateUsersTable < ActiveRecord::Migration',
' def change',
' create_table :users do |t|',
' t.string :name, null: false',
' t.timestamps null: false',
' end',
' end',
'end']
end
include_examples 'accepts'
end
context 'with add_reference call' do
context 'with null: false' do
let(:source) { 'add_reference :products, :category, null: false' }
it 'reports an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['Do not add a NOT NULL column without a default value.']
)
end
end
context 'with default option' do
let(:source) do
'add_reference :products, :category, null: false, default: 1'
end
include_examples 'accepts'
end
context 'without any options' do
let(:source) { 'add_reference :products, :category' }
include_examples 'accepts'
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/output_safety_spec.rb 0000664 0000000 0000000 00000005001 13070542236 0025701 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::OutputSafety do
subject(:cop) { described_class.new }
it 'registers an offense for html_safe methods with a receiver and no ' \
'arguments' do
source = ['foo.html_safe',
'"foo".html_safe']
inspect_source(cop, source)
expect(cop.offenses.size).to eq(2)
end
it 'accepts html_safe methods without a receiver' do
source = 'html_safe'
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'accepts html_safe methods with arguments' do
source = ['foo.html_safe one',
'"foo".html_safe two']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'registers an offense for raw methods without a receiver' do
source = ['raw(foo)',
'raw "foo"']
inspect_source(cop, source)
expect(cop.offenses.size).to eq(2)
end
it 'accepts raw methods with a receiver' do
source = ['foo.raw(foo)',
'"foo".raw "foo"']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'accepts raw methods without arguments' do
source = 'raw'
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'accepts raw methods with more than one arguments' do
source = 'raw one, two'
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'accepts comments' do
source = ['# foo.html_safe',
'# raw foo']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'accepts raw methods when wrapped in a safe_join' do
source = 'safe_join([raw(i18n_text),
raw(i18n_mode_additional_markup(key))])'
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'accepts html_safe methods when wrapped in a safe_join' do
source = 'safe_join([i18n_text.html_safe,
i18n_mode_additional_markup(key).html_safe])'
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'accepts raw methods when wrapped in safe_join when not at the root' do
source = 'foo(safe_join([i18n_text.html_safe,
i18n_mode_additional_markup(key).html_safe]))'
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'accepts raw methods when wrapped in a safe_join when not at the root' do
source = 'foo(safe_join([raw(i18n_text),
raw(i18n_mode_additional_markup(key))]))'
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/output_spec.rb 0000664 0000000 0000000 00000001711 13070542236 0024332 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::Output do
subject(:cop) { described_class.new }
it 'records an offense for methods without a receiver' do
source = ['p "edmond dantes"',
'puts "sinbad"',
'print "abbe busoni"',
'pp "monte cristo"']
inspect_source(cop, source)
expect(cop.offenses.size).to eq(4)
end
it 'does not record an offense for methods with a receiver' do
source = ['obj.print',
'something.p',
'nothing.pp']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'does not record an offense for methods without arguments' do
source = %w[print pp puts]
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'does not record an offense for comments' do
source = ['# print "test"',
'# p']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/pluralization_grammar_spec.rb 0000664 0000000 0000000 00000006424 13070542236 0027403 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::PluralizationGrammar do
subject(:cop) { described_class.new }
before do
inspect_source(cop, source)
end
shared_examples 'enforces pluralization grammar' do |method_name|
context "When #{method_name} is called on an unknown variable" do
context "when using the plural form ##{method_name}s" do
let(:source) { "some_variable.#{method_name}s" }
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
context "when using the singular form ##{method_name}" do
let(:source) { "some_method.#{method_name}" }
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
end
[1, 1.0].each do |singular_literal|
context "when mis-pluralizing #{method_name} with #{singular_literal}" do
let(:source) { "#{singular_literal}.#{method_name}s.ago" }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(["#{singular_literal}.#{method_name}s"])
expect(cop.messages).to eq(
["Prefer `#{singular_literal}.#{method_name}`."]
)
end
it 'autocorrects to be grammatically correct' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{singular_literal}.#{method_name}.ago")
end
end
context "when using the singular form ##{method_name}" do
let(:source) { "#{singular_literal}.#{method_name}" }
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
end
context "when #{method_name} is called on any other literal number" do
[-rand(2..1000),
rand(-1.0...0),
-1,
0,
rand(0...1.0),
rand(2..1000)].each do |plural_number|
context "when using the plural form ##{method_name}s" do
let(:source) { "#{plural_number}.#{method_name}s" }
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
context "when using the singular form ##{method_name}" do
let(:source) { "#{plural_number}.#{method_name}.from_now" }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(["#{plural_number}.#{method_name}"])
expect(cop.messages).to eq(
["Prefer `#{plural_number}.#{method_name}s`."]
)
end
it 'autocorrects to be grammatically correct' do
new_source = autocorrect_source(cop, source)
expect(new_source)
.to eq("#{plural_number}.#{method_name}s.from_now")
end
end
end
end
end
it_behaves_like 'enforces pluralization grammar', 'second'
it_behaves_like 'enforces pluralization grammar', 'minute'
it_behaves_like 'enforces pluralization grammar', 'hour'
it_behaves_like 'enforces pluralization grammar', 'day'
it_behaves_like 'enforces pluralization grammar', 'week'
it_behaves_like 'enforces pluralization grammar', 'fortnight'
it_behaves_like 'enforces pluralization grammar', 'month'
it_behaves_like 'enforces pluralization grammar', 'year'
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/present_spec.rb 0000664 0000000 0000000 00000020632 13070542236 0024455 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::Present, :config do
subject(:cop) { described_class.new(config) }
shared_examples :offense do |source, correction, message|
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq([message])
expect(cop.highlights).to eq([source])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(correction)
end
end
context 'NotNilAndNotEmpty set to true' do
let(:cop_config) do
{ 'NotNilAndNotEmpty' => true,
'NotBlank' => false,
'UnlessBlank' => false }
end
it 'accepts checking nil?' do
inspect_source(cop, 'foo.nil?')
expect(cop.offenses).to be_empty
end
it 'accepts checking empty?' do
inspect_source(cop, 'foo.empty?')
expect(cop.offenses).to be_empty
end
it 'accepts checking nil? || empty? on different objects' do
inspect_source(cop, 'foo.nil? || bar.empty?')
expect(cop.offenses).to be_empty
end
it 'accepts checking existance && not empty? on different objects' do
inspect_source(cop, 'foo && !bar.empty?')
expect(cop.offenses).to be_empty
end
it_behaves_like :offense, 'foo && !foo.empty?',
'foo.present?',
'Use `foo.present?` instead of `foo && !foo.empty?`.'
it_behaves_like :offense, '!foo.nil? && !foo.empty?',
'foo.present?',
'Use `foo.present?` instead of `!foo.nil? && !foo.empty?`.'
it_behaves_like :offense, 'foo != nil && !foo.empty?',
'foo.present?',
'Use `foo.present?` instead of `foo != nil && !foo.empty?`.'
it_behaves_like :offense, '!!foo && !foo.empty?',
'foo.present?',
'Use `foo.present?` instead of `!!foo && !foo.empty?`.'
context 'checking all variable types' do
it_behaves_like :offense, '!foo.nil? && !foo.empty?',
'foo.present?',
'Use `foo.present?` instead of ' \
'`!foo.nil? && !foo.empty?`.'
it_behaves_like :offense, '!foo.bar.nil? && !foo.bar.empty?',
'foo.bar.present?',
'Use `foo.bar.present?` instead of ' \
'`!foo.bar.nil? && !foo.bar.empty?`.'
it_behaves_like :offense, '!FOO.nil? && !FOO.empty?',
'FOO.present?',
'Use `FOO.present?` instead of ' \
'`!FOO.nil? && !FOO.empty?`.'
it_behaves_like :offense, '!Foo.nil? && !Foo.empty?',
'Foo.present?',
'Use `Foo.present?` instead of ' \
'`!Foo.nil? && !Foo.empty?`.'
it_behaves_like :offense, '!@foo.nil? && !@foo.empty?',
'@foo.present?',
'Use `@foo.present?` instead of ' \
'`!@foo.nil? && !@foo.empty?`.'
it_behaves_like :offense, '!$foo.nil? && !$foo.empty?',
'$foo.present?',
'Use `$foo.present?` instead of ' \
'`!$foo.nil? && !$foo.empty?`.'
it_behaves_like :offense, '!@@foo.nil? && !@@foo.empty?',
'@@foo.present?',
'Use `@@foo.present?` instead of ' \
'`!@@foo.nil? && !@@foo.empty?`.'
it_behaves_like :offense, '!foo[bar].nil? && !foo[bar].empty?',
'foo[bar].present?',
'Use `foo[bar].present?` instead of ' \
'`!foo[bar].nil? && !foo[bar].empty?`.'
it_behaves_like :offense, '!Foo::Bar.nil? && !Foo::Bar.empty?',
'Foo::Bar.present?',
'Use `Foo::Bar.present?` instead of ' \
'`!Foo::Bar.nil? && !Foo::Bar.empty?`.'
it_behaves_like :offense, '!foo(bar).nil? && !foo(bar).empty?',
'foo(bar).present?',
'Use `foo(bar).present?` instead of ' \
'`!foo(bar).nil? && !foo(bar).empty?`.'
end
end
context 'NotBlank set to true' do
let(:cop_config) do
{ 'NotNilAndNotEmpty' => false,
'NotBlank' => true,
'UnlessBlank' => false }
end
it_behaves_like :offense, '!foo.blank?',
'foo.present?',
'Use `foo.present?` instead of `!foo.blank?`.'
it_behaves_like :offense, 'not foo.blank?',
'foo.present?',
'Use `foo.present?` instead of `not foo.blank?`.'
end
context 'UnlessBlank set to true' do
let(:cop_config) do
{ 'NotNilAndNotEmpty' => false,
'NotBlank' => false,
'UnlessBlank' => true }
end
it 'accepts modifier if blank?' do
inspect_source(cop, 'something if foo.blank?')
expect(cop.offenses).to be_empty
end
it 'accepts modifier unless present?' do
inspect_source(cop, 'something unless foo.present?')
expect(cop.offenses).to be_empty
end
it 'accepts normal if blank?' do
inspect_source(cop, ['if foo.blank?',
' something',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts normal unless present?' do
inspect_source(cop, ['unless foo.present?',
' something',
'end'])
expect(cop.offenses).to be_empty
end
context 'unless blank?' do
context 'modifier unless' do
let(:source) { 'something unless foo.blank?' }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages)
.to eq(['Use `if foo.present?` instead of `unless foo.blank?`.'])
expect(cop.highlights).to eq(['unless foo.blank?'])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('something if foo.present?')
end
end
context 'normal unless blank?' do
let(:source) do
['unless foo.blank?',
' something',
'end']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages)
.to eq(['Use `if foo.present?` instead of `unless foo.blank?`.'])
expect(cop.highlights).to eq(['unless foo.blank?'])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['if foo.present?',
' something',
'end'].join("\n"))
end
end
context 'unless blank? with an else' do
let(:source) do
['unless foo.blank?',
' something',
'else',
' something_else',
'end']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages)
.to eq(['Use `if foo.present?` instead of `unless foo.blank?`.'])
expect(cop.highlights).to eq(['unless foo.blank?'])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['if foo.present?',
' something',
'else',
' something_else',
'end'].join("\n"))
end
end
end
end
context 'NotNilAndNotEmpty set to false' do
let(:cop_config) do
{ 'NotNilAndNotEmpty' => false,
'NotBlank' => true,
'UnlessBlank' => true }
end
it 'accepts checking nil? || empty?' do
inspect_source(cop, 'foo.nil? || foo.empty?')
expect(cop.offenses).to be_empty
end
end
context 'NotBlank set to false' do
let(:cop_config) do
{ 'NotNilAndNotEmpty' => true,
'NotBlank' => false,
'UnlessBlank' => true }
end
it 'accepts !...blank?' do
inspect_source(cop, '!foo.blank?')
expect(cop.offenses).to be_empty
end
end
context 'UnlessBlank set to false' do
let(:cop_config) do
{ 'NotNilAndNotEmpty' => true,
'NotBlank' => true,
'UnlessBlank' => false }
end
it 'accepts unless blank?' do
inspect_source(cop, 'something unless foo.blank?')
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/read_write_attribute_spec.rb 0000664 0000000 0000000 00000007105 13070542236 0027205 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::ReadWriteAttribute do
subject(:cop) { described_class.new }
context 'read_attribute' do
it 'registers an offense' do
inspect_source(cop, 'res = read_attribute(:test)')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['read_attribute'])
end
it 'registers no offense with explicit receiver' do
inspect_source(cop, 'res = object.read_attribute(:test)')
expect(cop.offenses).to be_empty
end
end
context 'write_attribute' do
it 'registers an offense' do
inspect_source(cop, 'write_attribute(:test, val)')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['write_attribute'])
end
it 'registers no offense with explicit receiver' do
inspect_source(cop, 'object.write_attribute(:test, val)')
expect(cop.offenses).to be_empty
end
end
describe '#autocorrect' do
context 'write_attribute' do
it 'autocorrects symbol' do
source = 'write_attribute(:attr, var)'
corrected_source = 'self[:attr] = var'
expect(autocorrect_source(cop, source)).to eq(corrected_source)
end
it 'autocorrects string' do
source = "write_attribute('attr', 'test')"
corrected_source = "self['attr'] = 'test'"
expect(autocorrect_source(cop, source)).to eq(corrected_source)
end
it 'autocorrects without parentheses' do
source = "write_attribute 'attr', 'test'"
corrected_source = "self['attr'] = 'test'"
expect(autocorrect_source(cop, source)).to eq(corrected_source)
end
it 'autocorrects expression' do
source = "write_attribute(:attr, 'test_' + postfix)"
corrected_source = "self[:attr] = 'test_' + postfix"
expect(autocorrect_source(cop, source)).to eq(corrected_source)
end
it 'autocorrects multiline' do
source = [
'write_attribute(',
':attr, ',
'(',
"'test_' + postfix",
').to_sym',
')'
]
corrected_source = [
'self[:attr] = (',
"'test_' + postfix",
').to_sym'
].join("\n")
expect(autocorrect_source(cop, source)).to eq(corrected_source)
end
end
context 'read_attribute' do
it 'autocorrects symbol' do
source = 'res = read_attribute(:test)'
corrected_source = 'res = self[:test]'
expect(autocorrect_source(cop, source)).to eq(corrected_source)
end
it 'autocorrects string' do
source = "res = read_attribute('test')"
corrected_source = "res = self['test']"
expect(autocorrect_source(cop, source)).to eq(corrected_source)
end
it 'autocorrects without parentheses' do
source = "res = read_attribute 'test'"
corrected_source = "res = self['test']"
expect(autocorrect_source(cop, source)).to eq(corrected_source)
end
it 'autocorrects expression' do
source = "res = read_attribute('test_' + postfix)"
corrected_source = "res = self['test_' + postfix]"
expect(autocorrect_source(cop, source)).to eq(corrected_source)
end
it 'autocorrects multiline' do
source = [
'res = read_attribute(',
'(',
"'test_' + postfix",
').to_sym',
')'
]
corrected_source = [
'res = self[(',
"'test_' + postfix",
').to_sym]'
].join("\n")
expect(autocorrect_source(cop, source)).to eq(corrected_source)
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/relative_date_constant_spec.rb 0000664 0000000 0000000 00000004017 13070542236 0027515 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::RelativeDateConstant do
subject(:cop) { described_class.new }
it 'registers an offense for ActiveSupport::Duration.since' do
inspect_source(cop,
['class SomeClass',
' EXPIRED_AT = 1.week.since',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'accepts a method with arguments' do
inspect_source(cop,
['class SomeClass',
' EXPIRED_AT = 1.week.since(base)',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts a lambda' do
inspect_source(cop,
['class SomeClass',
' EXPIRED_AT = -> { 1.year.ago }',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts a proc' do
inspect_source(cop,
['class SomeClass',
' EXPIRED_AT = Proc.new { 1.year.ago }',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for exclusive end range' do
inspect_source(cop,
['class SomeClass',
' TRIAL_PERIOD = DateTime.current..1.day.since',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for inclusive end range' do
inspect_source(cop,
['class SomeClass',
' TRIAL_PERIOD = DateTime.current...1.day.since',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'autocorrects' do
new_source = autocorrect_source(cop,
['class SomeClass',
' EXPIRED_AT = 1.week.since',
'end'])
expect(new_source).to eq(['class SomeClass',
' def self.expired_at',
' 1.week.since',
' end',
'end'].join("\n"))
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/request_referer_spec.rb 0000664 0000000 0000000 00000003005 13070542236 0026172 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::RequestReferer, :config do
subject(:cop) { described_class.new(config) }
context 'when EnforcedStyle is referer' do
before { inspect_source(cop, 'puts request.referrer') }
let(:cop_config) { { 'EnforcedStyle' => 'referer' } }
it 'registers an offense for request.referrer' do
expect(cop.offenses.size).to eq(1)
end
it 'highlights the offence' do
expect(cop.highlights).to eq(['request.referrer'])
end
it 'sends a message to the user' do
expect(cop.messages)
.to eq(['Use `request.referer` instead of `request.referrer`.'])
end
it 'autocorrects referrer with referer' do
corrected = autocorrect_source(cop, ['puts request.referrer'])
expect(corrected).to eq 'puts request.referer'
end
end
context 'when EnforcedStyle is referrer' do
before { inspect_source(cop, 'puts request.referer') }
let(:cop_config) { { 'EnforcedStyle' => 'referrer' } }
it 'registers an offense for request.referer' do
expect(cop.offenses.size).to eq(1)
end
it 'highlights the offence' do
expect(cop.highlights).to eq(['request.referer'])
end
it 'sends a message to the user' do
expect(cop.messages)
.to eq(['Use `request.referrer` instead of `request.referer`.'])
end
it 'autocorrects referer with referrer' do
corrected = autocorrect_source(cop, ['puts request.referer'])
expect(corrected).to eq 'puts request.referrer'
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/reversible_migration_spec.rb 0000664 0000000 0000000 00000006074 13070542236 0027214 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::ReversibleMigration do
subject(:cop) { described_class.new }
let(:source) do
<<-RUBY
class ExampleMigration < ActiveRecord::Migration
def change
#{code}
end
end
RUBY
end
shared_examples :accepts do |name, code|
let(:code) { code }
it "accepts usages of #{name}" do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
shared_examples :offense do |name, code|
let(:code) { code }
it "registers an offense for #{name}" do
inspect_source(cop, source)
expect(cop.messages).to eq(["#{name} is not reversible."])
end
end
it_behaves_like :accepts, 'create_table', <<-RUBY
create_table :users do |t|
t.string :name
end
RUBY
it_behaves_like :offense, 'change_table', <<-RUBY
change_table :users do |t|
t.column :name, :string
end
RUBY
context 'within block' do
it_behaves_like :accepts, 'create_table', <<-RUBY
[:users, :articles].each do |table|
create_table table do |t|
t.string :name
end
end
RUBY
it_behaves_like :offense, 'change_table', <<-RUBY
[:users, :articles].each do |table|
change_table table do |t|
t.column :name, :string
end
end
RUBY
end
context 'within #reversible' do
it_behaves_like :accepts, 'change_table', <<-RUBY
reversible do |dir|
change_table :users do |t|
dir.up do
t.column :name, :string
end
dir.down do
t.remove :name
end
end
end
RUBY
end
context 'drop_table' do
it_behaves_like :accepts, 'drop_table(with block)', <<-RUBY
drop_table :users do |t|
t.string :name
end
RUBY
it_behaves_like :offense, 'drop_table(without block)', <<-RUBY
drop_table :users
RUBY
end
context 'change_column_default' do
it_behaves_like :accepts,
'change_column_default(with :from and :to)', <<-RUBY
change_column_default(:posts, :state, from: nil, to: "draft")
RUBY
it_behaves_like :offense,
'change_column_default(without :from and :to)', <<-RUBY
change_column_default(:suppliers, :qualification, 'new')
RUBY
end
context 'remove_column' do
it_behaves_like :accepts, 'remove_column(with type)', <<-RUBY
remove_column(:suppliers, :qualification, :string)
RUBY
it_behaves_like :accepts, 'remove_column(with type and options)', <<-RUBY
remove_column(:suppliers, :qualification, :string, null: false)
RUBY
it_behaves_like :offense, 'remove_column(without type)', <<-RUBY
remove_column(:suppliers, :qualification)
RUBY
end
context 'remove_foreign_key' do
it_behaves_like :accepts, 'remove_foreign_key(with table)', <<-RUBY
remove_foreign_key :accounts, :branches
RUBY
it_behaves_like :offense, 'remove_foreign_key(without table)', <<-RUBY
remove_foreign_key :accounts, column: :owner_id
RUBY
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/safe_navigation_spec.rb 0000664 0000000 0000000 00000022217 13070542236 0026133 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::SafeNavigation, :config do
subject(:cop) { described_class.new(config) }
shared_examples :accepts do |name, code|
it "accepts usages of #{name}" do
inspect_source(cop, "[1, 2].#{code}")
expect(cop.offenses).to be_empty
end
end
shared_examples :offense do |name, method, params|
it "registers an offense for #{name}" do
inspect_source(cop, "[1, 2].#{method}#{params}")
expect(cop.messages)
.to eq([format('Use safe navigation (`&.`) instead of `%s`.', method)])
end
end
shared_examples :autocorrect do |name, source, correction|
it "corrects #{name}" do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(correction)
end
end
context 'only convert try!' do
let(:cop_config) { { 'ConvertTry' => false } }
it_behaves_like :accepts, 'non try! method calls', 'join'
context 'target_ruby_version < 2.3', :ruby19 do
it_behaves_like :accepts, 'try! with a single parameter', 'try!(:join)'
it_behaves_like :accepts, 'try! with a multiple parameters',
'try!(:join, ",")'
it_behaves_like :accepts, 'try! with a block',
'try!(:map) { |e| e.some_method }'
it_behaves_like :accepts, 'try! with params and a block',
['try!(:each_with_object, []) do |e, acc|',
' acc << e.some_method',
'end'].join("\n")
end
context 'target_ruby_version > 2.3', :ruby23 do
context 'try!' do
it_behaves_like :offense, 'try! with a single parameter', 'try!',
'(:join)'
it_behaves_like :offense, 'try! with a multiple parameters', 'try!',
'(:join, ",")'
it_behaves_like :offense, 'try! with a block', 'try!',
'(:map) { |e| e.some_method }'
it_behaves_like :offense, 'try! with params and a block', 'try!',
['(:each_with_object, []) do |e, acc|',
' acc << e.some_method',
'end'].join("\n")
it_behaves_like :offense, 'try! with a question method', 'try!',
'(:something?)'
it_behaves_like :offense, 'try! with a bang method', 'try!',
'(:something!)'
it_behaves_like :accepts, 'try! used to call an enumerable accessor',
'foo.try!(:[], :bar)'
it_behaves_like :accepts, 'try! with ==', 'foo.try!(:==, bar)'
it_behaves_like :accepts, 'try! with an operator', 'foo.try!(:+, bar)'
it_behaves_like :accepts, 'try! with a method stored as a variable',
['bar = :==',
'foo.try!(baz, bar)'].join("\n")
it 'accepts usages of try! without receiver' do
inspect_source(cop, 'try!(:something)')
expect(cop.offenses).to be_empty
end
end
context 'try' do
it_behaves_like :accepts, 'try with a single parameter', 'try(:join)'
it_behaves_like :accepts, 'try with a multiple parameters',
'try(:join, ",")'
it_behaves_like :accepts, 'try with a block',
'try(:map) { |e| e.some_method }'
it_behaves_like :accepts, 'try with params and a block',
['try(:each_with_object, []) do |e, acc|',
' acc << e.some_method',
'end'].join("\n")
end
it_behaves_like :autocorrect, 'try! a single parameter',
'foo.try!(:thing=, bar)', 'foo&.thing = bar'
it_behaves_like :autocorrect, 'try! a single parameter',
'[1, 2].try!(:join)', '[1, 2]&.join'
it_behaves_like :autocorrect, 'try! with 2 parameters',
'[1, 2].try!(:join, ",")', '[1, 2]&.join(",")'
it_behaves_like :autocorrect, 'try! with multiple parameters',
'[1, 2].try!(:join, bar, baz)', '[1, 2]&.join(bar, baz)'
it_behaves_like :autocorrect, 'try! with a block',
['[foo, bar].try!(:map) do |e|',
' e.some_method',
'end'].join("\n"),
['[foo, bar]&.map do |e|',
' e.some_method',
'end'].join("\n")
it_behaves_like :autocorrect, 'try! with params and a block',
['[foo, bar].try!(:each_with_object, []) do |e, acc|',
' acc << e.some_method',
'end'].join("\n"),
['[foo, bar]&.each_with_object([]) do |e, acc|',
' acc << e.some_method',
'end'].join("\n")
end
end
context 'convert try and try!' do
let(:cop_config) { { 'ConvertTry' => true } }
context 'target_ruby_version < 2.3', :ruby19 do
it_behaves_like :accepts, 'try! with a single parameter', 'try!(:join)'
it_behaves_like :accepts, 'try! with a multiple parameters',
'try!(:join, ",")'
it_behaves_like :accepts, 'try! with a block',
'try!(:map) { |e| e.some_method }'
it_behaves_like :accepts, 'try! with params and a block',
['try!(:each_with_object, []) do |e, acc|',
' acc << e.some_method',
'end'].join("\n")
end
context 'target_ruby_version > 2.3', :ruby23 do
context 'try!' do
it_behaves_like :offense, 'try! with a single parameter', 'try!',
'(:join)'
it_behaves_like :offense, 'try! with a multiple parameters', 'try!',
'(:join, ",")'
it_behaves_like :offense, 'try! with a block', 'try!',
'(:map) { |e| e.some_method }'
it_behaves_like :offense, 'try! with params and a block', 'try!',
['(:each_with_object, []) do |e, acc|',
' acc << e.some_method',
'end'].join("\n")
it_behaves_like :accepts, 'try! used to call an enumerable accessor',
'foo.try!(:[], :bar)'
it_behaves_like :autocorrect, 'try! a single parameter',
'[1, 2].try!(:join)', '[1, 2]&.join'
it_behaves_like :autocorrect, 'try! with 2 parameters',
'[1, 2].try!(:join, ",")', '[1, 2]&.join(",")'
it_behaves_like :autocorrect, 'try! with multiple parameters',
'[1, 2].try!(:join, bar, baz)', '[1, 2]&.join(bar, baz)'
it_behaves_like :autocorrect, 'try! with a block',
['[foo, bar].try!(:map) do |e|',
' e.some_method',
'end'].join("\n"),
['[foo, bar]&.map do |e|',
' e.some_method',
'end'].join("\n")
it_behaves_like :autocorrect, 'try! with params and a block',
['[foo, bar].try!(:each_with_object, []) do |e, acc|',
' acc << e.some_method',
'end'].join("\n"),
['[foo, bar]&.each_with_object([]) do |e, acc|',
' acc << e.some_method',
'end'].join("\n")
end
context 'try' do
it_behaves_like :offense, 'try with a single parameter', 'try',
'(:join)'
it_behaves_like :offense, 'try with a multiple parameters', 'try',
'(:join, ",")'
it_behaves_like :offense, 'try with a block', 'try',
'(:map) { |e| e.some_method }'
it_behaves_like :offense, 'try with params and a block', 'try',
['(:each_with_object, []) do |e, acc|',
' acc << e.some_method',
'end'].join("\n")
it_behaves_like :accepts, 'try! used to call an enumerable accessor',
'foo.try!(:[], :bar)'
it_behaves_like :autocorrect, 'try a single parameter',
'[1, 2].try(:join)', '[1, 2]&.join'
it_behaves_like :autocorrect, 'try with 2 parameters',
'[1, 2].try(:join, ",")', '[1, 2]&.join(",")'
it_behaves_like :autocorrect, 'try with multiple parameters',
'[1, 2].try(:join, bar, baz)', '[1, 2]&.join(bar, baz)'
it_behaves_like :autocorrect, 'try with a block',
['[foo, bar].try(:map) do |e|',
' e.some_method',
'end'].join("\n"),
['[foo, bar]&.map do |e|',
' e.some_method',
'end'].join("\n")
it_behaves_like :autocorrect, 'try with params and a block',
['[foo, bar].try(:each_with_object, []) do |e, acc|',
' acc << e.some_method',
'end'].join("\n"),
['[foo, bar]&.each_with_object([]) do |e, acc|',
' acc << e.some_method',
'end'].join("\n")
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/save_bang_spec.rb 0000664 0000000 0000000 00000011750 13070542236 0024723 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::SaveBang do
subject(:cop) { described_class.new }
shared_examples 'checks_common_offense' do |method|
it "when using #{method} with arguments" do
inspect_source(cop, "object.#{method}(name: 'Tom', age: 20)")
if method == :destroy
expect(cop.messages).to be_empty
else
expect(cop.messages)
.to eq(["Use `#{method}!` instead of `#{method}` " \
'if the return value is not checked.'])
end
end
it "when using #{method} without arguments" do
inspect_source(cop, method.to_s)
expect(cop.messages)
.to eq(["Use `#{method}!` instead of `#{method}` " \
'if the return value is not checked.'])
end
it "when using #{method}!" do
inspect_source(cop, "object.#{method}!")
expect(cop.messages).to be_empty
end
it "when using #{method} with 2 arguments" do
inspect_source(cop, "Model.#{method}(1, name: 'Tom')")
expect(cop.messages).to be_empty
end
it "when using #{method} with wrong argument" do
inspect_source(cop, "object.#{method}('Tom')")
expect(cop.messages).to be_empty
end
it 'autocorrects' do
new_source = autocorrect_source(cop, "object.#{method}()")
expect(new_source).to eq("object.#{method}!()")
end
end
shared_examples 'checks_variable_return_use_offense' do |method, pass|
it "when assigning the return value of #{method}" do
inspect_source(cop, "x = object.#{method}\n")
if pass
expect(cop.messages).to be_empty
else
expect(cop.messages)
.to eq(["Use `#{method}!` instead of `#{method}` " \
'if the return value is not checked.' \
" Or check `persisted?` on model returned from `#{method}`."])
end
end
it "when assigning the return value of #{method} with block" do
inspect_source(cop, "x = object.#{method} do |obj|\n" \
" obj.name = 'Tom'\n" \
'end')
if pass
expect(cop.messages).to be_empty
else
expect(cop.messages)
.to eq(["Use `#{method}!` instead of `#{method}` " \
'if the return value is not checked.' \
" Or check `persisted?` on model returned from `#{method}`."])
end
end
it "when using #{method} with if" do
inspect_source(cop, "if object.#{method}; something; end")
if pass
expect(cop.messages).to be_empty
else
expect(cop.messages)
.to eq(["`#{method}` returns a model which is always truthy."])
end
end
it "when using #{method} with multiple conditional" do
inspect_source(cop, ["if true && object.active? && object.#{method}",
' something',
'end'])
if pass
expect(cop.messages).to be_empty
else
expect(cop.messages)
.to eq(["`#{method}` returns a model which is always truthy."])
end
end
it "when using #{method} with oneline if" do
inspect_source(cop, "something if object.#{method}")
if pass
expect(cop.messages).to be_empty
else
expect(cop.messages)
.to eq(["`#{method}` returns a model which is always truthy."])
end
end
it "when using #{method} with oneline if and multiple conditional" do
inspect_source(cop, "something if false || object.#{method}")
if pass
expect(cop.messages).to be_empty
else
expect(cop.messages)
.to eq(["`#{method}` returns a model which is always truthy."])
end
end
it "when using #{method} as last method call" do
inspect_source(cop, ['def foo', "object.#{method}", 'end'])
expect(cop.messages).to be_empty
end
end
described_class::MODIFY_PERSIST_METHODS.each do |method|
it_behaves_like('checks_common_offense', method)
it_behaves_like('checks_variable_return_use_offense', method, true)
end
shared_examples 'checks_create_offense' do |method|
it "when using persisted? after #{method}" do
inspect_source(cop, "x = object.#{method}\n" \
'if x.persisted? then; something; end')
expect(cop.messages).to be_empty
end
it "when using persisted? after #{method} with block" do
inspect_source(cop, "x = object.#{method} do |obj|\n" \
" obj.name = 'Tom'\n" \
"end\n" \
'if x.persisted? then; something; end')
expect(cop.messages).to be_empty
end
end
described_class::CREATE_PERSIST_METHODS.each do |method|
it_behaves_like('checks_common_offense', method)
it_behaves_like('checks_variable_return_use_offense', method, false)
it_behaves_like('checks_create_offense', method)
end
it 'properly ignores lvasign without right hand side' do
inspect_source(cop, 'variable += 1')
expect(cop.messages).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/scope_args_spec.rb 0000664 0000000 0000000 00000002726 13070542236 0025126 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::ScopeArgs do
subject(:cop) { described_class.new }
it 'registers an offense a scope with a method arg' do
inspect_source(cop, 'scope :active, where(active: true)')
expect(cop.offenses.size).to eq(1)
end
it 'accepts a non send argument' do
inspect_source(cop, 'scope :active, "adsf"')
expect(cop.offenses).to be_empty
end
it 'accepts a stabby lambda' do
inspect_source(cop, 'scope :active, -> { where(active: true) }')
expect(cop.offenses).to be_empty
end
it 'accepts a stabby lambda with arguments' do
inspect_source(cop, 'scope :active, ->(active) { where(active: active) }')
expect(cop.offenses).to be_empty
end
it 'accepts a lambda' do
inspect_source(cop, 'scope :active, lambda { where(active: true) }')
expect(cop.offenses).to be_empty
end
it 'accepts a lambda with a block argument' do
inspect_source(cop,
'scope :active, lambda { |active| where(active: active) }')
expect(cop.offenses).to be_empty
end
it 'accepts a lambda with a multiline block' do
inspect_source(cop, ['scope :active, (lambda do |active|',
' where(active: active)',
' end)'])
expect(cop.offenses).to be_empty
end
it 'accepts a proc' do
inspect_source(cop, 'scope :active, proc { where(active: true) }')
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/skips_model_validations_spec.rb 0000664 0000000 0000000 00000004603 13070542236 0027703 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::SkipsModelValidations, :config do
cop_config = {
'Blacklist' => %w[decrement!
decrement_counter
increment!
increment_counter
toggle!
touch
update_all
update_attribute
update_column
update_columns
update_counters]
}
subject(:cop) { described_class.new(config) }
let(:msg) { 'Avoid using `%s` because it skips validations.' }
let(:cop_config) { cop_config }
methods_with_arguments = described_class::METHODS_WITH_ARGUMENTS
context 'with default blacklist' do
cop_config['Blacklist'].each do |method_name|
it "registers an offense for `#{method_name}`" do
inspect_source(cop, "User.#{method_name}(:attr)")
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq([format(msg, method_name)])
end
end
end
context 'with methods that require at least an argument' do
methods_with_arguments.each do |method_name|
it "doesn't register an offense for `#{method_name}`" do
inspect_source(cop, "User.#{method_name}")
expect(cop.offenses).to be_empty
end
end
end
context "with methods that don't require an argument" do
(cop_config['Blacklist'] - methods_with_arguments).each do |method_name|
it "registers an offense for `#{method_name}`" do
inspect_source(cop, "User.#{method_name}")
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq([format(msg, method_name)])
end
end
end
context 'with `update_attribute` method in blacklist' do
let(:cop_config) do
{ 'Blacklist' => %w[update_attribute] }
end
whitelist = cop_config['Blacklist'].reject do |val|
val == 'update_attribute'
end
whitelist.each do |method_name|
it "accepts `#{method_name}`" do
inspect_source(cop, "User.#{method_name}")
expect(cop.offenses).to be_empty
end
end
it 'registers an offense for `update_attribute`' do
inspect_source(cop, 'user.update_attribute(\'website\': \'example.com\')')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq([format(msg, 'update_attribute')])
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/time_zone_spec.rb 0000664 0000000 0000000 00000022767 13070542236 0025001 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::TimeZone, :config do
subject(:cop) { described_class.new(config) }
context 'when EnforcedStyle is "strict"' do
let(:cop_config) { { 'EnforcedStyle' => 'strict' } }
described_class::TIMECLASS.each do |klass|
it "registers an offense for #{klass}.now" do
inspect_source(cop, "#{klass}.now")
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to include('`Time.zone.now`')
end
it "registers an offense for #{klass}.current" do
inspect_source(cop, "#{klass}.current")
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to include('`Time.zone.now`')
end
it "registers an offense for #{klass}.new without argument" do
inspect_source(cop, "#{klass}.new")
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to include('`Time.zone.now`')
end
it "registers an offense for #{klass}.new with argument" do
inspect_source(cop, "#{klass}.new(2012, 6, 10, 12, 00)")
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to include('`Time.zone.local`')
end
it 'does not register an offense when a .new method is made
independently of the Time class' do
inspect_source(cop,
'Range.new(1,
Time.days_in_month(date.month, date.year))')
expect(cop.offenses).to be_empty
end
it "does not register an offense for #{klass}.new with zone argument" do
inspect_source(cop, "#{klass}.new(1988, 3, 15, 3, 0, 0, '-05:00')")
expect(cop.offenses).to be_empty
end
it "registers an offense for ::#{klass}.now" do
inspect_source(cop, "::#{klass}.now")
expect(cop.offenses.size).to eq(1)
end
it "accepts Some::#{klass}.now" do
inspect_source(cop, "Some::#{klass}.forward(0).strftime('%H:%M')")
expect(cop.offenses).to be_empty
end
described_class::ACCEPTED_METHODS.each do |a_method|
it "registers an offense #{klass}.now.#{a_method}" do
inspect_source(cop, "#{klass}.now.#{a_method}")
expect(cop.offenses.size).to eq(1)
end
end
end
it 'registers an offense for Time.parse' do
inspect_source(cop, 'Time.parse("2012-03-02 16:05:37")')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for Time.strftime' do
inspect_source(cop, 'Time.strftime(time_string, "%Y-%m-%dT%H:%M:%S%z")')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for Time.strftime.in_time_zone' do
inspect_source(
cop,
'Time.strftime(time_string, "%Y-%m-%dT%H:%M:%S%z").in_time_zone'
)
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for Time.strftime with nested Time.zone' do
inspect_source(
cop,
'Time.strftime(Time.zone.now.to_s, "%Y-%m-%dT%H:%M:%S%z")'
)
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for Time.zone.strftime with nested Time.now' do
inspect_source(
cop,
'Time.zone.strftime(Time.now.to_s, "%Y-%m-%dT%H:%M:%S%z")'
)
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for Time.at' do
inspect_source(cop, 'Time.at(ts)')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for Time.at.in_time_zone' do
inspect_source(cop, 'Time.at(ts).in_time_zone')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for Time.parse.localtime(offset)' do
inspect_source(cop, "Time.parse('12:00').localtime('+03:00')")
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for Time.parse.localtime' do
inspect_source(cop, "Time.parse('12:00').localtime")
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for Time.parse in return' do
inspect_source(cop, 'return Foo, Time.parse("2012-03-02 16:05:37")')
expect(cop.offenses.size).to eq(1)
end
it 'accepts Time.zone.now' do
inspect_source(cop, 'Time.zone.now')
expect(cop.offenses).to be_empty
end
it 'accepts Time.zone.today' do
inspect_source(cop, 'Time.zone.today')
expect(cop.offenses).to be_empty
end
it 'accepts Time.zone.local' do
inspect_source(cop, 'Time.zone.local(2012, 6, 10, 12, 00)')
expect(cop.offenses).to be_empty
end
it 'accepts Time.zone.parse' do
inspect_source(cop, 'Time.zone.parse("2012-03-02 16:05:37")')
expect(cop.offenses).to be_empty
end
it 'accepts Time.zone.at' do
inspect_source(cop, 'Time.zone.at(ts)')
expect(cop.offenses).to be_empty
end
it 'accepts Time.strptime' do
inspect_source(cop, 'Time.strptime(datetime, format).in_time_zone')
expect(cop.offenses).to be_empty
end
it 'accepts Time.zone.strftime' do
inspect_source(
cop,
'Time.zone.strftime(time_string, "%Y-%m-%dT%H:%M:%S%z")'
)
expect(cop.offenses).to be_empty
end
it 'accepts Time.zone.parse.localtime' do
inspect_source(cop, "Time.zone.parse('12:00').localtime")
expect(cop.offenses).to be_empty
end
it 'accepts Time.zone.parse.localtime(offset)' do
inspect_source(cop, "Time.zone.parse('12:00').localtime('+03:00')")
expect(cop.offenses).to be_empty
end
it 'accepts Time.zone_default.now' do
inspect_source(cop, 'Time.zone_default.now')
expect(cop.offenses).to be_empty
end
it 'accepts Time.zone_default.today' do
inspect_source(cop, 'Time.zone_default.today')
expect(cop.offenses).to be_empty
end
it 'accepts Time.zone_default.local' do
inspect_source(cop, 'Time.zone_default.local(2012, 6, 10, 12, 00)')
expect(cop.offenses).to be_empty
end
it 'accepts Time.find_zone(time_zone).now' do
inspect_source(cop, "Time.find_zone('EST').now")
expect(cop.offenses).to be_empty
end
it 'accepts Time.find_zone(time_zone).today' do
inspect_source(cop, "Time.find_zone('EST').today")
expect(cop.offenses).to be_empty
end
it 'accepts Time.find_zone(time_zone).local' do
inspect_source(cop, "Time.find_zone('EST').local(2012, 6, 10, 12, 00)")
expect(cop.offenses).to be_empty
end
it 'accepts Time.find_zone!(time_zone).now' do
inspect_source(cop, "Time.find_zone!('EST').now")
expect(cop.offenses).to be_empty
end
it 'accepts Time.find_zone!(time_zone).today' do
inspect_source(cop, "Time.find_zone!('EST').today")
expect(cop.offenses).to be_empty
end
it 'accepts Time.find_zone!(time_zone).local' do
inspect_source(cop, "Time.find_zone!('EST').local(2012, 6, 10, 12, 00)")
expect(cop.offenses).to be_empty
end
described_class::DANGEROUS_METHODS.each do |a_method|
it "accepts Some::Time.#{a_method}" do
inspect_source(cop, "Some::Time.#{a_method}")
expect(cop.offenses).to be_empty
end
end
end
context 'when EnforcedStyle is "flexible"' do
let(:cop_config) { { 'EnforcedStyle' => 'flexible' } }
described_class::TIMECLASS.each do |klass|
it "registers an offense for #{klass}.now" do
inspect_source(cop, "#{klass}.now")
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to include('Use one of')
expect(cop.offenses.first.message).to include('`Time.zone.now`')
expect(cop.offenses.first.message).to include("`#{klass}.current`")
described_class::ACCEPTED_METHODS.each do |a_method|
expect(cop.offenses.first.message)
.to include("#{klass}.now.#{a_method}")
end
end
it "accepts #{klass}.current" do
inspect_source(cop, "#{klass}.current")
expect(cop.offenses).to be_empty
end
described_class::ACCEPTED_METHODS.each do |a_method|
it "accepts #{klass}.now.#{a_method}" do
inspect_source(cop, "#{klass}.now.#{a_method}")
expect(cop.offenses).to be_empty
end
end
it "accepts #{klass}.zone.now" do
inspect_source(cop, "#{klass}.zone.now")
expect(cop.offenses).to be_empty
end
it "accepts #{klass}.zone_default.now" do
inspect_source(cop, "#{klass}.zone_default.now")
expect(cop.offenses).to be_empty
end
it "accepts #{klass}.find_zone(time_zone).now" do
inspect_source(cop, "#{klass}.find_zone('EST').now")
expect(cop.offenses).to be_empty
end
it "accepts #{klass}.find_zone!(time_zone).now" do
inspect_source(cop, "#{klass}.find_zone!('EST').now")
expect(cop.offenses).to be_empty
end
described_class::DANGEROUS_METHODS.each do |a_method|
it "accepts #{klass}.current.#{a_method}" do
inspect_source(cop, "#{klass}.current.#{a_method}")
expect(cop.offenses).to be_empty
end
end
end
it 'accepts Time.strftime.in_time_zone' do
inspect_source(
cop,
'Time.strftime(time_string, "%Y-%m-%dT%H:%M:%S%z").in_time_zone'
)
expect(cop.offenses).to be_empty
end
it 'accepts Time.parse.localtime(offset)' do
inspect_source(cop, "Time.parse('12:00').localtime('+03:00')")
expect(cop.offenses).to be_empty
end
it 'does not blow up in the presence of a single constant to inspect' do
inspect_source(cop, 'A')
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/uniq_before_pluck_spec.rb 0000664 0000000 0000000 00000006101 13070542236 0026464 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::UniqBeforePluck, :config do
subject(:cop) { described_class.new(config) }
shared_examples_for 'UniqBeforePluck cop' \
do |method, source, action, corrected = nil|
if action == :correct
it "finds the use of #{method} after pluck in #{source}" do
inspect_source(cop, source)
expect(cop.messages).to eq(["Use `#{method}` before `pluck`."])
expect(cop.highlights).to eq([method])
corrected_source = corrected || "Model.#{method}.pluck(:id)"
expect(autocorrect_source(cop, source)).to eq(corrected_source)
end
else
it "ignores pluck without errors in #{source}" do
inspect_source(cop, source)
expect(cop.messages).to be_empty
expect(cop.highlights).to be_empty
expect(cop.offenses).to be_empty
end
end
end
shared_examples_for 'mode independent behavior' do |method|
it_behaves_like 'UniqBeforePluck cop', method,
"Model.pluck(:id).#{method}", :correct
it_behaves_like 'UniqBeforePluck cop', method,
['Model.pluck(:id)',
" .#{method}"], :correct
it_behaves_like 'UniqBeforePluck cop', method,
['Model.pluck(:id).',
" #{method}"], :correct
context "#{method} before pluck" do
it_behaves_like 'UniqBeforePluck cop', method,
"Model.where(foo: 1).#{method}.pluck(:something)", :ignore
end
context "#{method} without a receiver" do
it_behaves_like 'UniqBeforePluck cop', method,
"#{method}.something", :ignore
end
context "#{method} without pluck" do
it_behaves_like 'UniqBeforePluck cop', method,
"Model.#{method}", :ignore
end
context "#{method} with a block" do
it_behaves_like 'UniqBeforePluck cop', method,
"Model.where(foo: 1).pluck(:id).#{method} { |k| k[0] }",
:ignore
end
end
shared_examples_for 'mode dependent offenses' do |method, action|
it_behaves_like 'UniqBeforePluck cop', method,
"Model.scope.pluck(:id).#{method}", action,
"Model.scope.#{method}.pluck(:id)"
it_behaves_like 'UniqBeforePluck cop', method,
"instance.assoc.pluck(:id).#{method}", action,
"instance.assoc.#{method}.pluck(:id)"
end
%w[uniq distinct].each do |method|
context 'when the enforced mode is conservative' do
let(:cop_config) do
{ 'EnforcedStyle' => 'conservative', 'AutoCorrect' => true }
end
it_behaves_like 'mode independent behavior', method
it_behaves_like 'mode dependent offenses', method, :ignore
end
context 'when the enforced mode is aggressive' do
let(:cop_config) do
{ 'EnforcedStyle' => 'aggressive', 'AutoCorrect' => true }
end
it_behaves_like 'mode independent behavior', method
it_behaves_like 'mode dependent offenses', method, :correct
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/rails/validation_spec.rb 0000664 0000000 0000000 00000002424 13070542236 0025126 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Rails::Validation do
subject(:cop) { described_class.new }
described_class::BLACKLIST.each_with_index do |validation, number|
it "registers an offense for #{validation}" do
inspect_source(cop, "#{validation} :name")
expect(cop.offenses.size).to eq(1)
end
it "outputs the correct message for #{validation}" do
inspect_source(cop, "#{validation} :name")
expect(cop.offenses.first.message)
.to include(described_class::WHITELIST[number])
end
end
described_class::TYPES.each_with_index do |parameter|
it "autocorrect validates_#{parameter}_of" do
new_source = autocorrect_source(
cop,
"validates_#{parameter}_of :full_name, :birth_date"
)
expect(new_source).to eq(
"validates :full_name, :birth_date, #{parameter}: true"
)
end
end
it 'accepts new style validations' do
inspect_source(cop, 'validates :name')
expect(cop.offenses).to be_empty
end
it 'autocorrect validates_length_of' do
new_source = autocorrect_source(
cop,
'validates_numericality_of :age, minimum: 0, maximum: 122'
)
expect(new_source).to eq(
'validates :age, numericality: { minimum: 0, maximum: 122 }'
)
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/registry_spec.rb 0000664 0000000 0000000 00000011744 13070542236 0023537 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Registry do
subject(:registry) { described_class.new(cops) }
let(:cops) do
stub_const('RuboCop::Cop::Test', Module.new)
stub_const('RuboCop::Cop::RSpec', Module.new)
module RuboCop
module Cop
module Test
# Create another cop with a different namespace
class IndentArray < Cop
end
end
module RSpec
# Define a dummy rspec cop which has special namespace inflection
class Foo < Cop
end
end
end
end
[
RuboCop::Cop::Lint::ConditionPosition,
RuboCop::Cop::Lint::DuplicateMethods,
RuboCop::Cop::Style::IndentArray,
RuboCop::Cop::Metrics::MethodLength,
RuboCop::Cop::RSpec::Foo,
RuboCop::Cop::Test::IndentArray
]
end
# `RuboCop::Cop::Cop` mutates its `registry` when inherited from.
# This can introduce nondeterministic failures in other parts of the
# specs if this mutation occurs before code that depends on this global cop
# store. The workaround is to replace the global cop store with a temporary
# store during these tests
around do |test|
registry = RuboCop::Cop::Cop.registry
temporary_store = described_class.new(registry.cops)
RuboCop::Cop::Cop.instance_variable_set(:@registry, temporary_store)
test.run
RuboCop::Cop::Cop.instance_variable_set(:@registry, registry)
end
it 'exposes cop departments' do
expect(registry.departments).to eql(%i[Lint Style Metrics RSpec Test])
end
it 'can filter down to one type' do
expect(registry.with_department(:Lint))
.to eq(described_class.new(cops.first(2)))
end
it 'can filter down to all but one type' do
expect(registry.without_department(:Lint))
.to eq(described_class.new(cops.drop(2)))
end
context '#contains_cop_matching?' do
it 'can find cops matching a given name' do
expect(registry.contains_cop_matching?(['Test/IndentArray'])).to be(true)
end
it 'returns false for cops not included in the store' do
expect(registry.contains_cop_matching?(['Style/NotReal'])).to be(false)
end
end
context '#qualified_cop_name' do
let(:origin) { '/app/.rubocop.yml' }
it 'gives back already properly qualified names' do
expect(registry.qualified_cop_name('Style/IndentArray', origin))
.to eql('Style/IndentArray')
end
it 'qualifies names without a namespace' do
expect(registry.qualified_cop_name('MethodLength', origin))
.to eql('Metrics/MethodLength')
end
it 'qualifies names with the correct namespace' do
expect(registry.qualified_cop_name('Foo', origin)).to eql('RSpec/Foo')
end
it 'emits a warning when namespace is incorrect' do
warning = '/app/.rubocop.yml: Style/MethodLength has the wrong ' \
"namespace - should be Metrics\n"
qualified = nil
expect do
qualified = registry.qualified_cop_name('Style/MethodLength', origin)
end.to output(warning).to_stderr
expect(qualified).to eql('Metrics/MethodLength')
end
it 'raises an error when a cop name is ambiguous' do
expect { registry.qualified_cop_name('IndentArray', origin) }
.to raise_error(RuboCop::Cop::AmbiguousCopName).with_message(
'Ambiguous cop name `IndentArray` used in /app/.rubocop.yml needs ' \
'department qualifier. Did you mean Style/IndentArray or ' \
'Test/IndentArray?'
)
end
it 'returns the provided name if no namespace is found' do
expect(registry.qualified_cop_name('NotReal', origin)).to eql('NotReal')
end
end
it 'exposes a mapping of cop names to cop classes' do
expect(registry.to_h).to eql(
'Lint/ConditionPosition' => [RuboCop::Cop::Lint::ConditionPosition],
'Lint/DuplicateMethods' => [RuboCop::Cop::Lint::DuplicateMethods],
'Style/IndentArray' => [RuboCop::Cop::Style::IndentArray],
'Metrics/MethodLength' => [RuboCop::Cop::Metrics::MethodLength],
'Test/IndentArray' => [RuboCop::Cop::Test::IndentArray],
'RSpec/Foo' => [RuboCop::Cop::RSpec::Foo]
)
end
context '#cops' do
it 'exposes a list of cops' do
expect(registry.cops).to eql(cops)
end
end
it 'exposes the number of stored cops' do
expect(registry.length).to be(6)
end
context '#enabled' do
let(:config) do
RuboCop::Config.new('Test/IndentArray' => { 'Enabled' => false })
end
it 'selects cops which are enabled in the config' do
expect(registry.enabled(config, [])).to eql(cops.first(5))
end
it 'overrides config if :only includes the cop' do
expect(registry.enabled(config, ['Test/IndentArray'])).to eql(cops)
end
end
it 'exposes a list of cop names' do
expect(registry.names).to eql(
[
'Lint/ConditionPosition',
'Lint/DuplicateMethods',
'Style/IndentArray',
'Metrics/MethodLength',
'RSpec/Foo',
'Test/IndentArray'
]
)
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/security/ 0000775 0000000 0000000 00000000000 13070542236 0022170 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/security/eval_spec.rb 0000664 0000000 0000000 00000003342 13070542236 0024460 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Security::Eval do
subject(:cop) { described_class.new }
it 'registers an offense for eval as function' do
inspect_source(cop, 'eval(something)')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights) .to eq(['eval'])
end
it 'registers an offense for eval as command' do
inspect_source(cop, 'eval something')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['eval'])
end
it 'does not register an offense for eval as variable' do
inspect_source(cop, 'eval = something')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for eval as method' do
inspect_source(cop, 'something.eval')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for eval on a literal string' do
inspect_source(cop, 'eval("puts 1")')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for eval with no arguments' do
inspect_source(cop, 'eval')
expect(cop.offenses).to be_empty
end
context 'with an explicit binding, filename, and line number' do
it 'registers an offense for eval as function' do
inspect_source(cop, 'eval(something, binding, "test.rb", 1)')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights) .to eq(['eval'])
end
it 'registers an offense for eval as command' do
inspect_source(cop, 'eval something, binding, "test.rb", 1')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['eval'])
end
it 'does not register an offense for eval on a literal string' do
inspect_source(cop, 'eval("puts 1", binding, "test.rb", 1)')
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/security/json_load_spec.rb 0000664 0000000 0000000 00000003520 13070542236 0025477 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Security::JSONLoad, :config do
subject(:cop) { described_class.new(config) }
before do
inspect_source(cop, source)
end
shared_examples 'code with offense' do |code, message, expected|
context "when checking #{code}" do
let(:source) { code }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(message)
end
it 'auto-corrects' do
expect(autocorrect_source(cop, code)).to eq expected
end
end
end
shared_examples 'code without offense' do |code|
context "when checking #{code}" do
let(:source) { code }
it 'does not register any offense' do
expect(cop.offenses).to be_empty
end
end
end
shared_examples 'accepted method' do |method|
include_examples 'code without offense',
"JSON.#{method}(arg)"
include_examples 'code without offense',
"::JSON.#{method}(arg)"
include_examples 'code without offense',
"Module::JSON.#{method}(arg)"
end
shared_examples 'offensive method' do |method|
include_examples 'code with offense',
"JSON.#{method}(arg)",
"Prefer `JSON.parse` over `JSON.#{method}`.",
'JSON.parse(arg)'
include_examples 'code with offense',
"::JSON.#{method}(arg)",
"Prefer `JSON.parse` over `JSON.#{method}`.",
'::JSON.parse(arg)'
include_examples 'code without offense',
"Module::JSON.#{method}(arg)"
end
include_examples 'accepted method', :parse
include_examples 'accepted method', :dump
include_examples 'offensive method', :load
include_examples 'offensive method', :restore
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/security/marshal_load_spec.rb 0000664 0000000 0000000 00000003273 13070542236 0026162 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Security::MarshalLoad, :config do
subject(:cop) { described_class.new(config) }
before do
inspect_source(cop, source)
end
shared_examples 'code with offense' do |code, message|
context "when checking #{code}" do
let(:source) { code }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(message)
end
end
end
shared_examples 'code without offense' do |code|
context "when checking #{code}" do
let(:source) { code }
it 'does not register any offense' do
expect(cop.offenses).to be_empty
end
end
end
shared_examples 'offensive method' do |method|
include_examples 'code with offense',
"Marshal.#{method}('{}')",
"Avoid using `Marshal.#{method}`."
include_examples 'code with offense',
"::Marshal.#{method}('{}')",
"Avoid using `Marshal.#{method}`."
include_examples 'code without offense',
"Module::Marshal.#{method}('{}')"
include_examples 'code without offense',
"Marshal.#{method}(Marshal.dump({}))"
include_examples 'code without offense',
"::Marshal.#{method}(::Marshal.dump({}))"
end
include_examples 'code without offense',
'Marshal.dump({})'
include_examples 'code without offense',
'::Marshal.dump({})'
include_examples 'code without offense',
'Module::Marshal.dump({})'
include_examples 'offensive method', :load
include_examples 'offensive method', :restore
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/security/yaml_load_spec.rb 0000664 0000000 0000000 00000003035 13070542236 0025471 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Security::YAMLLoad, :config do
subject(:cop) { described_class.new(config) }
before do
inspect_source(cop, source)
end
shared_examples 'code with offense' do |code, message, expected|
context "when checking #{code}" do
let(:source) { code }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(message)
end
it 'auto-corrects' do
expect(autocorrect_source(cop, code)).to eq expected
end
end
end
shared_examples 'code without offense' do |code|
context "when checking #{code}" do
let(:source) { code }
it 'does not register any offense' do
expect(cop.offenses).to be_empty
end
end
end
include_examples 'code without offense',
'YAML.dump("foo")'
include_examples 'code without offense',
'::YAML.dump("foo")'
include_examples 'code without offense',
'Module::YAML.dump("foo")'
include_examples 'code with offense',
'YAML.load("--- foo")',
'Prefer using `YAML.safe_load` over `YAML.load`.',
'YAML.safe_load("--- foo")'
include_examples 'code with offense',
'::YAML.load("--- foo")',
'Prefer using `YAML.safe_load` over `YAML.load`.',
'::YAML.safe_load("--- foo")'
include_examples 'code without offense',
'Module::YAML.load("foo")'
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/severity_spec.rb 0000664 0000000 0000000 00000004633 13070542236 0023540 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Severity do
let(:refactor) { described_class.new(:refactor) }
let(:convention) { described_class.new(:convention) }
let(:warning) { described_class.new(:warning) }
let(:error) { described_class.new(:error) }
let(:fatal) { described_class.new(:fatal) }
it 'has a few required attributes' do
expect(convention.name).to eq(:convention)
end
it 'overrides #to_s' do
expect(convention.to_s).to eq('convention')
end
it 'redefines == to compare severities' do
expect(convention).to eq(:convention)
expect(convention).to eq(described_class.new(:convention))
expect(convention).not_to eq(:warning)
end
it 'is frozen' do
expect(convention).to be_frozen
end
describe '#code' do
describe 'refactor' do
it { expect(refactor.code).to eq('R') }
end
describe 'convention' do
it { expect(convention.code).to eq('C') }
end
describe 'warning' do
it { expect(warning.code).to eq('W') }
end
describe 'error' do
it { expect(error.code).to eq('E') }
end
describe 'fatal' do
it { expect(fatal.code).to eq('F') }
end
end
describe '#level' do
describe 'refactor' do
it { expect(refactor.level).to eq(1) }
end
describe 'convention' do
it { expect(convention.level).to eq(2) }
end
describe 'warning' do
it { expect(warning.level).to eq(3) }
end
describe 'error' do
it { expect(error.level).to eq(4) }
end
describe 'fatal' do
it { expect(fatal.level).to eq(5) }
end
end
describe 'constructs from code' do
describe 'R' do
it { expect(described_class.new('R')).to eq(refactor) }
end
describe 'C' do
it { expect(described_class.new('C')).to eq(convention) }
end
describe 'W' do
it { expect(described_class.new('W')).to eq(warning) }
end
describe 'E' do
it { expect(described_class.new('E')).to eq(error) }
end
describe 'F' do
it { expect(described_class.new('F')).to eq(fatal) }
end
end
describe 'Comparable' do
describe 'refactor' do
it { expect(refactor).to be < convention }
end
describe 'convention' do
it { expect(convention).to be < warning }
end
describe 'warning' do
it { expect(warning).to be < error }
end
describe 'error' do
it { expect(error).to be < fatal }
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/ 0000775 0000000 0000000 00000000000 13070542236 0021461 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/access_modifier_indentation_spec.rb 0000664 0000000 0000000 00000036466 13070542236 0030552 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::AccessModifierIndentation do
subject(:cop) { described_class.new(config) }
let(:config) do
c = cop_config.merge('SupportedStyles' => %w[indent outdent])
RuboCop::Config
.new('Style/AccessModifierIndentation' => c,
'Style/IndentationWidth' => { 'Width' => indentation_width })
end
let(:indentation_width) { 2 }
context 'when EnforcedStyle is set to indent' do
let(:cop_config) { { 'EnforcedStyle' => 'indent' } }
it 'registers an offense for misaligned private' do
inspect_source(cop,
['class Test',
'',
'private',
'',
' def test; end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Indent access modifiers like `private`.'])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'outdent')
end
it 'registers an offense for misaligned private in module' do
inspect_source(cop,
['module Test',
'',
' private',
'',
' def test; end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Indent access modifiers like `private`.'])
# Not aligned according to `indent` or `outdent` style:
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'registers an offense for misaligned module_function in module' do
inspect_source(cop,
['module Test',
'',
' module_function',
'',
' def test; end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Indent access modifiers like `module_function`.'])
# Not aligned according to `indent` or `outdent` style:
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'registers an offense for correct + opposite alignment' do
inspect_source(cop,
['module Test',
'',
' public',
'',
'private',
'',
' def test; end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Indent access modifiers like `private`.'])
# No EnforcedStyle can allow both alignments:
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'registers an offense for opposite + correct alignment' do
inspect_source(cop,
['module Test',
'',
'public',
'',
' private',
'',
' def test; end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Indent access modifiers like `public`.'])
# No EnforcedStyle can allow both alignments:
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'registers an offense for misaligned private in singleton class' do
inspect_source(cop,
['class << self',
'',
'private',
'',
' def test; end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Indent access modifiers like `private`.'])
end
it 'registers an offense for misaligned private in class ' \
'defined with Class.new' do
inspect_source(cop,
['Test = Class.new do',
'',
'private',
'',
' def test; end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Indent access modifiers like `private`.'])
end
it 'accepts misaligned private in blocks that are not recognized as ' \
'class/module definitions' do
inspect_source(cop,
['Test = func do',
'',
'private',
'',
' def test; end',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for misaligned private in module ' \
'defined with Module.new' do
inspect_source(cop,
['Test = Module.new do',
'',
'private',
'',
' def test; end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Indent access modifiers like `private`.'])
end
it 'registers an offense for misaligned protected' do
inspect_source(cop,
['class Test',
'',
'protected',
'',
' def test; end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Indent access modifiers like `protected`.'])
end
it 'accepts properly indented private' do
inspect_source(cop,
['class Test',
'',
' private',
'',
' def test; end',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts properly indented protected' do
inspect_source(cop,
['class Test',
'',
' protected',
'',
' def test; end',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts an empty class' do
inspect_source(cop,
['class Test',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts methods with a body' do
inspect_source(cop, ['module Test',
' def test',
' foo',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'handles properly nested classes' do
inspect_source(cop,
['class Test',
'',
' class Nested',
'',
' private',
'',
' def a; end',
' end',
'',
' protected',
'',
' def test; end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Indent access modifiers like `private`.'])
end
it 'auto-corrects incorrectly indented access modifiers' do
corrected = autocorrect_source(cop, ['class Test',
'',
'public',
' private',
' protected',
'',
' def test; end',
'end'])
expect(corrected).to eq(['class Test',
'',
' public',
' private',
' protected',
'',
' def test; end',
'end'].join("\n"))
end
context 'when 4 spaces per indent level are used' do
let(:indentation_width) { 4 }
it 'accepts properly indented private' do
inspect_source(cop,
['class Test',
'',
' private',
'',
' def test; end',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'when indentation width is overridden for this cop only' do
let(:cop_config) do
{ 'EnforcedStyle' => 'indent', 'IndentationWidth' => 4 }
end
it 'accepts properly indented private' do
inspect_source(cop,
['class Test',
'',
' private',
'',
' def test; end',
'end'])
expect(cop.offenses).to be_empty
end
end
end
context 'when EnforcedStyle is set to outdent' do
let(:cop_config) { { 'EnforcedStyle' => 'outdent' } }
let(:indent_msg) { 'Outdent access modifiers like `private`.' }
it 'registers offense for private indented to method depth in a class' do
inspect_source(cop,
['class Test',
'',
' private',
'',
' def test; end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq([indent_msg])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'indent')
end
it 'registers offense for private indented to method depth in a module' do
inspect_source(cop,
['module Test',
'',
' private',
'',
' def test; end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq([indent_msg])
end
it 'registers offense for module fn indented to method depth in a module' do
inspect_source(cop,
['module Test',
'',
' module_function',
'',
' def test; end',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers offense for private indented to method depth in singleton' \
'class' do
inspect_source(cop,
['class << self',
'',
' private',
'',
' def test; end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq([indent_msg])
end
it 'registers offense for private indented to method depth in class ' \
'defined with Class.new' do
inspect_source(cop,
['Test = Class.new do',
'',
' private',
'',
' def test; end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq([indent_msg])
end
it 'registers offense for private indented to method depth in module ' \
'defined with Module.new' do
inspect_source(cop,
['Test = Module.new do',
'',
' private',
'',
' def test; end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq([indent_msg])
end
it 'accepts private indented to the containing class indent level' do
inspect_source(cop,
['class Test',
'',
'private',
'',
' def test; end',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts protected indented to the containing class indent level' do
inspect_source(cop,
['class Test',
'',
'protected',
'',
' def test; end',
'end'])
expect(cop.offenses).to be_empty
end
it 'handles properly nested classes' do
inspect_source(cop,
['class Test',
'',
' class Nested',
'',
' private',
'',
' def a; end',
' end',
'',
'protected',
'',
' def test; end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq([indent_msg])
end
it 'auto-corrects incorrectly indented access modifiers' do
corrected = autocorrect_source(cop, ['module M',
' class Test',
'',
'public',
' private',
' protected',
'',
' def test; end',
' end',
'end'])
expect(corrected).to eq(['module M',
' class Test',
'',
' public',
' private',
' protected',
'',
' def test; end',
' end',
'end'].join("\n"))
end
it 'auto-corrects private in complicated case' do
corrected = autocorrect_source(cop, ['class Hello',
' def foo',
" 'hi'",
' end',
'',
' def bar',
' Module.new do',
'',
' private',
'',
' def hi',
" 'bye'",
' end',
' end',
' end',
'end'])
expect(corrected).to eq(['class Hello',
' def foo',
" 'hi'",
' end',
'',
' def bar',
' Module.new do',
'',
' private',
'',
' def hi',
" 'bye'",
' end',
' end',
' end',
'end'].join("\n"))
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/accessor_method_name_spec.rb 0000664 0000000 0000000 00000005023 13070542236 0027162 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::AccessorMethodName do
subject(:cop) { described_class.new }
it 'registers an offense for method get_... with no args' do
inspect_source(cop, ['def get_attr',
' # ...',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['get_attr'])
end
it 'registers an offense for singleton method get_... with no args' do
inspect_source(cop, ['def self.get_attr',
' # ...',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['get_attr'])
end
it 'accepts method get_something with args' do
inspect_source(cop, ['def get_something(arg)',
' # ...',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts singleton method get_something with args' do
inspect_source(cop, ['def self.get_something(arg)',
' # ...',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for method set_something with one arg' do
inspect_source(cop, ['def set_attr(arg)',
' # ...',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['set_attr'])
end
it 'registers an offense for singleton method set_... with one args' do
inspect_source(cop, ['def self.set_attr(arg)',
' # ...',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['set_attr'])
end
it 'accepts method set_something with no args' do
inspect_source(cop, ['def set_something',
' # ...',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts singleton method set_something with no args' do
inspect_source(cop, ['def self.set_something',
' # ...',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts method set_something with two args' do
inspect_source(cop, ['def set_something(arg1, arg2)',
' # ...',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts singleton method set_something with two args' do
inspect_source(cop, ['def self.get_something(arg1, arg2)',
' # ...',
'end'])
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/alias_spec.rb 0000664 0000000 0000000 00000013430 13070542236 0024112 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::Alias, :config do
subject(:cop) { described_class.new(config) }
context 'when EnforcedStyle is prefer_alias_method' do
let(:cop_config) { { 'EnforcedStyle' => 'prefer_alias_method' } }
it 'registers an offense for alias with symbol args' do
inspect_source(cop, 'alias :ala :bala')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `alias_method` instead of `alias`.'])
end
it 'autocorrects alias with symbol args' do
corrected = autocorrect_source(cop, 'alias :ala :bala')
expect(corrected).to eq 'alias_method :ala, :bala'
end
it 'registers an offense for alias with bareword args' do
inspect_source(cop, 'alias ala bala')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `alias_method` instead of `alias`.'])
end
it 'autocorrects alias with bareword args' do
corrected = autocorrect_source(cop, 'alias ala bala')
expect(corrected).to eq 'alias_method :ala, :bala'
end
it 'does not register an offense for alias_method' do
inspect_source(cop, 'alias_method :ala, :bala')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for alias with gvars' do
inspect_source(cop, 'alias $ala $bala')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for alias in an instance_eval block' do
inspect_source(cop, ['module M',
' def foo',
' instance_eval {',
' alias bar baz',
' }',
' end',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'when EnforcedStyle is prefer_alias' do
let(:cop_config) { { 'EnforcedStyle' => 'prefer_alias' } }
it 'registers an offense for alias with symbol args' do
inspect_source(cop, 'alias :ala :bala')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `alias ala bala` instead of `alias :ala :bala`.'])
end
it 'autocorrects alias with symbol args' do
corrected = autocorrect_source(cop, ['alias :ala :bala'])
expect(corrected).to eq 'alias ala bala'
end
it 'does not register an offense for alias with bareword args' do
inspect_source(cop, 'alias ala bala')
expect(cop.offenses).to be_empty
end
it 'registers an offense for alias_method at the top level' do
inspect_source(cop, 'alias_method :ala, :bala')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `alias` instead of `alias_method` at the top level.'])
end
it 'autocorrects alias_method at the top level' do
corrected = autocorrect_source(cop, 'alias_method :ala, :bala')
expect(corrected).to eq 'alias ala bala'
end
it 'registers an offense for alias_method in a class block' do
inspect_source(cop, ['class C',
' alias_method :ala, :bala',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `alias` instead of `alias_method` in a class body.'])
end
it 'autocorrects alias_method in a class block' do
corrected = autocorrect_source(cop, ['class C',
' alias_method :ala, :bala',
'end'])
expect(corrected).to eq(['class C',
' alias ala bala',
'end'].join("\n"))
end
it 'registers an offense for alias_method in a module block' do
inspect_source(cop, ['module M',
' alias_method :ala, :bala',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `alias` instead of `alias_method` in a module body.'])
end
it 'autocorrects alias_method in a module block' do
corrected = autocorrect_source(cop, ['module M',
' alias_method :ala, :bala',
'end'])
expect(corrected).to eq(['module M',
' alias ala bala',
'end'].join("\n"))
end
it 'does not register an offense for alias_method with explicit receiver' do
inspect_source(cop, ['class C',
' receiver.alias_method :ala, :bala',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense for alias_method in a method def' do
inspect_source(cop, ['def method',
' alias_method :ala, :bala',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense for alias_method in self.method def' do
inspect_source(cop, ['def self.method',
' alias_method :ala, :bala',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense for alias_method in a block' do
inspect_source(cop, ['dsl_method do',
' alias_method :ala, :bala',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense for alias in an instance_eval block' do
inspect_source(cop, ['module M',
' def foo',
' instance_eval {',
' alias bar baz',
' }',
' end',
'end'])
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/align_array_spec.rb 0000664 0000000 0000000 00000011206 13070542236 0025310 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::AlignArray do
subject(:cop) { described_class.new }
it 'registers an offense for misaligned array elements' do
inspect_source(cop, ['array = [',
' a,',
' b,',
' c,',
' d',
']'])
expect(cop.messages).to eq(['Align the elements of an array ' \
'literal if they span more than ' \
'one line.'] * 2)
expect(cop.highlights).to eq(%w[b d])
end
it 'accepts aligned array keys' do
inspect_source(cop, ['array = [',
' a,',
' b,',
' c,',
' d',
']'])
expect(cop.offenses).to be_empty
end
it 'accepts single line array' do
inspect_source(cop, 'array = [ a, b ]')
expect(cop.offenses).to be_empty
end
it 'accepts several elements per line' do
inspect_source(cop, ['array = [ a, b,',
' c, d ]'])
expect(cop.offenses).to be_empty
end
it 'accepts aligned array with fullwidth characters' do
inspect_source(cop, ["puts 'Ｒｕｂｙ', [ a,",
' b ]'])
expect(cop.offenses).to be_empty
end
it 'auto-corrects alignment' do
new_source = autocorrect_source(cop, ['array = [',
' a,',
' b,',
' c,',
' d',
']'])
expect(new_source).to eq(['array = [',
' a,',
' b,',
' c,',
' d',
']'].join("\n"))
end
it 'does not auto-correct array within array with too much indentation' do
original_source = ['[:l1,',
' [:l2,',
'',
' [:l3,',
' [:l4]]]]']
new_source = autocorrect_source(cop, original_source)
expect(new_source).to eq(['[:l1,',
' [:l2,', # Corrected
'',
' [:l3,', # Not corrected
' [:l4]]]]'].join("\n"))
end
it 'does not auto-correct array within array with too little indentation' do
original_source = ['[:l1,',
'[:l2,',
'',
' [:l3,',
' [:l4]]]]']
new_source = autocorrect_source(cop, original_source)
expect(new_source).to eq(['[:l1,',
' [:l2,', # Corrected
'',
' [:l3,', # Not corrected
' [:l4]]]]'].join("\n"))
end
it 'auto-corrects only elements that begin a line' do
original_source = ['array = [:bar, {',
' whiz: 2, bang: 3 }, option: 3]']
new_source = autocorrect_source(cop, original_source)
expect(new_source).to eq(original_source.join("\n"))
end
it 'does not indent heredoc strings in autocorrect' do
original_source = ['var = [',
" { :type => 'something',",
' :sql => < 'something',",
' :sql => < 'something',",
' :sql => < 'something',",
' :sql => < {:a => messages,',
' :b => :json}, :status => 404',
'def example',
' a(',
' b: :c,',
' d: e(',
' f: g',
' ), h: :i)',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source.join("\n"))
end
end
context 'always inspect last argument hash' do
let(:cop_config) do
{
'EnforcedLastArgumentHashStyle' => 'always_inspect'
}
end
it 'registers offense for misaligned keys in implicit hash' do
inspect_source(cop, ['func(a: 0,',
' b: 1)'])
expect(cop.offenses.size).to eq(1)
end
it 'registers offense for misaligned keys in explicit hash' do
inspect_source(cop, ['func({a: 0,',
' b: 1})'])
expect(cop.offenses.size).to eq(1)
end
end
context 'always ignore last argument hash' do
let(:cop_config) do
{
'EnforcedLastArgumentHashStyle' => 'always_ignore'
}
end
it 'accepts misaligned keys in implicit hash' do
inspect_source(cop, ['func(a: 0,',
' b: 1)'])
expect(cop.offenses).to be_empty
end
it 'accepts misaligned keys in explicit hash' do
inspect_source(cop, ['func({a: 0,',
' b: 1})'])
expect(cop.offenses).to be_empty
end
end
context 'ignore implicit last argument hash' do
let(:cop_config) do
{
'EnforcedLastArgumentHashStyle' => 'ignore_implicit'
}
end
it 'accepts misaligned keys in implicit hash' do
inspect_source(cop, ['func(a: 0,',
' b: 1)'])
expect(cop.offenses).to be_empty
end
it 'registers offense for misaligned keys in explicit hash' do
inspect_source(cop, ['func({a: 0,',
' b: 1})'])
expect(cop.offenses.size).to eq(1)
end
end
context 'ignore explicit last argument hash' do
let(:cop_config) do
{
'EnforcedLastArgumentHashStyle' => 'ignore_explicit'
}
end
it 'registers offense for misaligned keys in implicit hash' do
inspect_source(cop, ['func(a: 0,',
' b: 1)'])
expect(cop.offenses.size).to eq(1)
end
it 'accepts misaligned keys in explicit hash' do
inspect_source(cop, ['func({a: 0,',
' b: 1})'])
expect(cop.offenses).to be_empty
end
end
let(:cop_config) do
{
'EnforcedHashRocketStyle' => 'key',
'EnforcedColonStyle' => 'key'
}
end
context 'with default configuration' do
it 'registers an offense for misaligned hash keys' do
inspect_source(cop, ['hash1 = {',
' a: 0,',
' bb: 1',
'}',
'hash2 = {',
" 'ccc' => 2,",
" 'dddd' => 2",
'}'])
expect(cop.messages).to eq(['Align the elements of a hash ' \
'literal if they span more than ' \
'one line.'] * 2)
expect(cop.highlights).to eq(['bb: 1',
"'dddd' => 2"])
end
it 'registers an offense for misaligned mixed multiline hash keys' do
inspect_source(cop, ['hash = { a: 1, b: 2,',
' c: 3 }'])
expect(cop.offenses.size).to eq(1)
end
it 'accepts aligned hash keys' do
inspect_source(cop, ['hash1 = {',
' a: 0,',
' bb: 1,',
'}',
'hash2 = {',
" 'ccc' => 2,",
" 'dddd' => 2",
'}'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for separator alignment' do
inspect_source(cop, ['hash = {',
" 'a' => 0,",
" 'bbb' => 1",
'}'])
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(["'bbb' => 1"])
end
context 'with implicit hash as last argument' do
it 'registers an offense for misaligned hash keys' do
inspect_source(cop, ['func(a: 0,',
' b: 1)'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for right alignment of keys' do
inspect_source(cop, ['func(a: 0,',
' bbb: 1)'])
expect(cop.offenses.size).to eq(1)
end
it 'accepts aligned hash keys' do
inspect_source(cop, ['func(a: 0,',
' b: 1)'])
expect(cop.offenses).to be_empty
end
it 'accepts an empty hash' do
inspect_source(cop, 'h = {}')
expect(cop.offenses).to be_empty
end
end
it 'auto-corrects alignment' do
new_source = autocorrect_source(cop, ['hash1 = { a: 0,',
' bb: 1,',
' ccc: 2 }',
'hash2 = { :a => 0,',
' :bb => 1,',
' :ccc =>2 }'])
expect(new_source).to eq(['hash1 = { a: 0,',
' bb: 1,',
' ccc: 2 }',
'hash2 = { :a => 0,',
' :bb => 1,',
# Separator and value are not corrected
# in 'key' mode.
' :ccc =>2 }'].join("\n"))
end
it 'auto-corrects alignment for mixed multiline hash keys' do
new_sources = autocorrect_source(cop, ['hash = { a: 1, b: 2,',
' c: 3 }'])
expect(new_sources).to eq(['hash = { a: 1, b: 2,',
' c: 3 }'].join("\n"))
end
context 'ruby >= 2.0', :ruby20 do
it 'auto-corrects alignment when using double splat ' \
'in an explicit hash' do
new_source = autocorrect_source(cop, ["Hash(foo: 'bar',",
' **extra_params',
')'].join("\n"))
expect(new_source).to eq(["Hash(foo: 'bar',",
' **extra_params',
')'].join("\n"))
end
it 'auto-corrects alignment when using double splat in braces' do
new_source = autocorrect_source(cop, ["{foo: 'bar',",
' **extra_params',
'}'].join("\n"))
expect(new_source).to eq(["{foo: 'bar',",
' **extra_params',
'}'].join("\n"))
end
end
end
include_examples 'not on separate lines'
context 'with table alignment configuration' do
let(:cop_config) do
{
'EnforcedHashRocketStyle' => 'table',
'EnforcedColonStyle' => 'table'
}
end
include_examples 'not on separate lines'
it 'accepts aligned hash keys and values' do
inspect_source(cop, ['hash1 = {',
" 'a' => 0,",
" 'bbb' => 1",
'}',
'hash2 = {',
' a: 0,',
' bbb: 1',
'}'])
expect(cop.offenses).to be_empty
end
it 'accepts an empty hash' do
inspect_source(cop, 'h = {}')
expect(cop.offenses).to be_empty
end
it 'accepts a multiline array of single line hashes' do
inspect_source(cop, ['def self.scenarios_order',
' [',
' { before: %w( l k ) },',
' { ending: %w( m l ) },',
' { starting: %w( m n ) },',
' { after: %w( n o ) }',
' ]',
' end'])
expect(cop.offenses).to be_empty
end
it 'accepts hashes that use different separators' do
inspect_source(cop, ['hash = {',
' a: 1,',
" 'bbb' => 2",
'}'])
expect(cop.offenses).to be_empty
end
context 'ruby >= 2.0', :ruby20 do
it 'accepts hashes that use different separators and double splats' do
inspect_source(cop, ['hash = {',
' a: 1,',
" 'bbb' => 2,",
' **foo',
'}'])
expect(cop.offenses).to be_empty
end
it 'accepts hashes that use different separators and double splats' do
inspect_source(cop, ['hash = {',
' a: 1,',
' **kw',
'}'])
expect(cop.offenses).to be_empty
end
end
it 'registers an offense for misaligned hash values' do
inspect_source(cop, ['hash1 = {',
" 'a' => 0,",
" 'bbb' => 1",
'}',
'hash2 = {',
' a: 0,',
' bbb:1',
'}'])
expect(cop.highlights).to eq(["'a' => 0",
'bbb:1'])
end
it 'registers an offense for misaligned hash keys' do
inspect_source(cop, ['hash1 = {',
" 'a' => 0,",
" 'bbb' => 1",
'}',
'hash2 = {',
' a: 0,',
' bbb: 1',
'}'])
expect(cop.highlights).to eq(["'a' => 0",
"'bbb' => 1",
'a: 0',
'bbb: 1'])
end
it 'registers an offense for misaligned hash rockets' do
inspect_source(cop, ['hash = {',
" 'a' => 0,",
" 'bbb' => 1",
'}'])
expect(cop.offenses.size).to eq(1)
end
it 'auto-corrects alignment' do
new_source = autocorrect_source(cop, ['hash1 = { a: 0,',
' bb: 1,',
' ccc: 2 }',
"hash2 = { 'a' => 0,",
" 'bb' => 1,",
" 'ccc' =>2 }"])
expect(new_source).to eq(['hash1 = { a: 0,',
' bb: 1,',
' ccc: 2 }',
"hash2 = { 'a' => 0,",
" 'bb' => 1,",
" 'ccc' => 2 }"].join("\n"))
end
end
context 'with table+separator alignment configuration' do
let(:cop_config) do
{
'EnforcedHashRocketStyle' => 'table',
'EnforcedColonStyle' => 'separator'
}
end
it 'accepts a single method argument entry with colon' do
inspect_source(cop, 'merge(parent: nil)')
expect(cop.offenses).to be_empty
end
end
context 'with invalid configuration' do
let(:cop_config) do
{
'EnforcedHashRocketStyle' => 'junk',
'EnforcedColonStyle' => 'junk'
}
end
it 'fails' do
src = ['hash = {',
' a: 0,',
' bb: 1',
'}']
expect { inspect_source(cop, src) }.to raise_error(RuntimeError)
end
end
context 'with separator alignment configuration' do
let(:cop_config) do
{
'EnforcedHashRocketStyle' => 'separator',
'EnforcedColonStyle' => 'separator'
}
end
it 'accepts aligned hash keys' do
inspect_source(cop, ['hash1 = {',
' a: 0,',
' bbb: 1',
'}',
'hash2 = {',
" 'a' => 0,",
" 'bbb' => 1",
'}'])
expect(cop.offenses).to be_empty
end
it 'accepts an empty hash' do
inspect_source(cop, 'h = {}')
expect(cop.offenses).to be_empty
end
it 'registers an offense for misaligned hash values' do
inspect_source(cop, ['hash = {',
" 'a' => 0,",
" 'bbb' => 1",
'}'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for misaligned hash rockets' do
inspect_source(cop, ['hash = {',
" 'a' => 0,",
" 'bbb' => 1",
'}'])
expect(cop.offenses.size).to eq(1)
end
context 'ruby >= 2.0', :ruby20 do
it 'accepts hashes with different separators' do
inspect_source(cop, ['{a: 1,',
" 'b' => 2,",
' **params}'])
expect(cop.offenses).to be_empty
end
end
include_examples 'not on separate lines'
it 'auto-corrects alignment' do
new_source = autocorrect_source(cop, ['hash1 = { a: 0,',
' bb: 1,',
' ccc: 2 }',
'hash2 = { a => 0,',
' bb => 1,',
' ccc =>2 }'])
expect(new_source).to eq(['hash1 = { a: 0,',
' bb: 1,',
' ccc: 2 }',
'hash2 = { a => 0,',
' bb => 1,',
' ccc => 2 }'].join("\n"))
end
it "doesn't break code by moving long keys too far left" do
# regression test; see GH issue 2582
new_source = autocorrect_source(cop, ['{',
' sjtjo: sjtjo,',
' too_ono_ilitjion_tofotono_o: ' \
'too_ono_ilitjion_tofotono_o,',
'}'])
expect(new_source).to eq(['{',
' sjtjo: sjtjo,',
'too_ono_ilitjion_tofotono_o: ' \
'too_ono_ilitjion_tofotono_o,',
'}'].join("\n"))
end
end
context 'with different settings for => and :' do
let(:cop_config) do
{
'EnforcedHashRocketStyle' => 'key',
'EnforcedColonStyle' => 'separator'
}
end
it 'registers offenses for misaligned entries' do
inspect_source(cop, ['hash1 = {',
' a: 0,',
' bbb: 1',
'}',
'hash2 = {',
" 'a' => 0,",
" 'bbb' => 1",
'}'])
expect(cop.highlights).to eq(['bbb: 1', "'bbb' => 1"])
end
it 'accepts aligned entries' do
inspect_source(cop, ['hash1 = {',
' a: 0,',
' bbb: 1',
'}',
'hash2 = {',
" 'a' => 0,",
" 'bbb' => 1",
'}'])
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/align_parameters_spec.rb 0000664 0000000 0000000 00000054351 13070542236 0026345 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::AlignParameters do
subject(:cop) { described_class.new(config) }
let(:config) do
RuboCop::Config.new('Style/AlignParameters' => cop_config,
'Style/IndentationWidth' => {
'Width' => indentation_width
})
end
let(:indentation_width) { 2 }
context 'aligned with first parameter' do
let(:cop_config) do
{
'EnforcedStyle' => 'with_first_parameter'
}
end
it 'registers an offense for parameters with single indent' do
inspect_source(cop, ['function(a,',
' if b then c else d end)'])
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['if b then c else d end'])
end
it 'registers an offense for parameters with double indent' do
inspect_source(cop, ['function(a,',
' if b then c else d end)'])
expect(cop.offenses.size).to eq(1)
end
it 'accepts multiline []= method call' do
inspect_source(cop, ['Test.config["something"] =',
' true'])
expect(cop.offenses).to be_empty
end
it 'accepts correctly aligned parameters' do
inspect_source(cop, ['function(a,',
' 0, 1,',
' (x + y),',
' if b then c else d end)'])
expect(cop.offenses).to be_empty
end
it 'accepts correctly aligned parameters with fullwidth characters' do
inspect_source(cop, ["f 'Ｒｕｂｙ', g(a,",
' b)'])
expect(cop.offenses).to be_empty
end
it 'accepts calls that only span one line' do
inspect_source(cop, 'find(path, s, @special[sexp[0]])')
expect(cop.offenses).to be_empty
end
it "doesn't get confused by a symbol argument" do
inspect_source(cop, ['add_offense(index,',
' MSG % kind)'])
expect(cop.offenses).to be_empty
end
it "doesn't get confused by splat operator" do
inspect_source(cop, ['func1(*a,',
' *b,',
' c)',
'func2(a,',
' *b,',
' c)',
'func3(*a)'])
expect(cop.offenses.map(&:to_s))
.to eq(['C: 5: 6: Align the parameters of a method call if ' \
'they span more than one line.'])
expect(cop.highlights).to eq(['*b'])
end
it "doesn't get confused by extra comma at the end" do
inspect_source(cop, ['func1(a,',
' b,)'])
expect(cop.offenses.map(&:to_s))
.to eq(['C: 2: 6: Align the parameters of a method call if ' \
'they span more than one line.'])
expect(cop.highlights).to eq(['b'])
end
it 'can handle a correctly aligned string literal as first argument' do
inspect_source(cop, ['add_offense(x,',
' a)'])
expect(cop.offenses).to be_empty
end
it 'can handle a string literal as other argument' do
inspect_source(cop, ['add_offense(',
' "", a)'])
expect(cop.offenses).to be_empty
end
it "doesn't get confused by a line break inside a parameter" do
inspect_source(cop, ['read(path, { headers: true,',
' converters: :numeric })'])
expect(cop.offenses).to be_empty
end
it "doesn't get confused by symbols with embedded expressions" do
inspect_source(cop, 'send(:"#{name}_comments_path")')
expect(cop.offenses).to be_empty
end
it "doesn't get confused by regexen with embedded expressions" do
inspect_source(cop, 'a(/#{name}/)')
expect(cop.offenses).to be_empty
end
it 'accepts braceless hashes' do
inspect_source(cop, ['run(collection, :entry_name => label,',
' :paginator => paginator)'])
expect(cop.offenses).to be_empty
end
it 'accepts the first parameter being on a new row' do
inspect_source(cop, [' match(',
' a,',
' b',
' )'])
expect(cop.offenses).to be_empty
end
it 'can handle heredoc strings' do
inspect_source(cop, ['class_eval(<<-EOS, __FILE__, __LINE__ + 1)',
' def run_#{name}_callbacks(*args)',
' a = 1',
' return value',
' end',
' EOS'])
expect(cop.offenses).to be_empty
end
it 'can handle a method call within a method call' do
inspect_source(cop, ['a(a1,',
' b(b1,',
' b2),',
' a2)'])
expect(cop.offenses).to be_empty
end
it 'can handle a call embedded in a string' do
inspect_source(cop, 'model("#{index(name)}", child)')
expect(cop.offenses).to be_empty
end
it 'can handle do-end' do
inspect_source(cop, [' run(lambda do |e|',
" w = e['warden']",
' end)'])
expect(cop.offenses).to be_empty
end
it 'can handle a call with a block inside another call' do
src = ['new(table_name,',
' exec_query("info(\'#{row[\'name\']}\')").map { |col|',
" col['name']",
' })']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'can handle a ternary condition with a block reference' do
inspect_source(cop, 'cond ? a : func(&b)')
expect(cop.offenses).to be_empty
end
it 'can handle parentheses used with no parameters' do
inspect_source(cop, 'func()')
expect(cop.offenses).to be_empty
end
it 'can handle a multiline hash as second parameter' do
inspect_source(cop, ['tag(:input, {',
' :value => value',
'})'])
expect(cop.offenses).to be_empty
end
it 'can handle method calls without parentheses' do
inspect_source(cop, 'a(b c, d)')
expect(cop.offenses).to be_empty
end
it 'can handle other method calls without parentheses' do
src = 'chars(Unicode.apply_mapping @wrapped_string, :uppercase)'
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it "doesn't crash and burn when there are nested issues" do
# regression test; see GH issue 2441
src = ['build(:house,',
' :rooms => [',
' build(:bedroom,',
' :bed => build(:bed,',
' :occupants => [],',
' :size => "king"',
' )',
' )',
' ]',
')']
expect { inspect_source(cop, src) }.not_to raise_error
end
context 'method definitions' do
it 'registers an offense for parameters with single indent' do
inspect_source(cop, ['def method(a,',
' b)',
'end'])
expect(cop.offenses.size).to eq 1
expect(cop.offenses.first.to_s).to match(/method definition/)
end
it 'registers an offense for parameters with double indent' do
inspect_source(cop, ['def method(a,',
' b)',
'end'])
expect(cop.offenses.size).to eq 1
end
it 'accepts parameter lists on a single line' do
inspect_source(cop, ['def method(a, b)',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts proper indentation' do
inspect_source(cop, ['def method(a,',
' b)',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts the first parameter being on a new row' do
inspect_source(cop, ['def method(',
' a,',
' b)',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts a method definition without parameters' do
inspect_source(cop, ['def method',
'end'])
expect(cop.offenses).to be_empty
end
it "doesn't get confused by splat" do
inspect_source(cop, ['def func2(a,',
' *b,',
' c)',
'end'])
expect(cop.offenses.size).to eq 1
expect(cop.highlights).to eq(['*b'])
end
it 'auto-corrects alignment' do
new_source = autocorrect_source(cop, ['def method(a,',
' b)',
'end'])
expect(new_source).to eq(['def method(a,',
' b)',
'end'].join("\n"))
end
context 'defining self.method' do
it 'registers an offense for parameters with single indent' do
inspect_source(cop, ['def self.method(a,',
' b)',
'end'])
expect(cop.offenses.size).to eq 1
expect(cop.offenses.first.to_s).to match(/method definition/)
end
it 'accepts proper indentation' do
inspect_source(cop, ['def self.method(a,',
' b)',
'end'])
expect(cop.offenses).to be_empty
end
it 'auto-corrects alignment' do
new_source = autocorrect_source(cop, ['def self.method(a,',
' b)',
'end'])
expect(new_source).to eq(['def self.method(a,',
' b)',
'end'].join("\n"))
end
end
end
context 'assigned methods' do
it 'accepts the first parameter being on a new row' do
inspect_source(cop, [' assigned_value = match(',
' a,',
' b,',
' c',
' )'])
expect(cop.offenses).to be_empty
end
it 'accepts the first parameter being on method row' do
inspect_source(cop, [' assigned_value = match(a,',
' b,',
' c',
' )'])
expect(cop.offenses).to be_empty
end
end
it 'auto-corrects alignment' do
new_source = autocorrect_source(cop, ['func(a,',
' b,',
'c)'])
expect(new_source).to eq(['func(a,',
' b,',
' c)'].join("\n"))
end
it 'auto-corrects each line of a multi-line parameter to the right' do
new_source =
autocorrect_source(cop,
['create :transaction, :closed,',
' account: account,',
' open_price: 1.29,',
' close_price: 1.30'])
expect(new_source)
.to eq(['create :transaction, :closed,',
' account: account,',
' open_price: 1.29,',
' close_price: 1.30'].join("\n"))
end
it 'auto-corrects each line of a multi-line parameter to the left' do
new_source =
autocorrect_source(cop,
['create :transaction, :closed,',
' account: account,',
' open_price: 1.29,',
' close_price: 1.30'])
expect(new_source)
.to eq(['create :transaction, :closed,',
' account: account,',
' open_price: 1.29,',
' close_price: 1.30'].join("\n"))
end
it 'auto-corrects only parameters that begin a line' do
original_source = ['foo(:bar, {',
' whiz: 2, bang: 3 }, option: 3)']
new_source = autocorrect_source(cop, original_source)
expect(new_source).to eq(original_source.join("\n"))
end
it 'does not crash in autocorrect on dynamic string in parameter value' do
src = ['class MyModel < ActiveRecord::Base',
' has_many :other_models,',
' class_name: "legacy_name",',
' order: "#{legacy_name.table_name}.published DESC"',
'',
'end']
new_source = autocorrect_source(cop, src)
expect(new_source)
.to eq ['class MyModel < ActiveRecord::Base',
' has_many :other_models,',
' class_name: "legacy_name",',
' order: "#{legacy_name.table_name}.published DESC"',
'',
'end'].join("\n")
end
end
context 'aligned with fixed indentation' do
let(:cop_config) do
{
'EnforcedStyle' => 'with_fixed_indentation'
}
end
let(:correct_source) do
[
'create :transaction, :closed,',
' account: account,',
' open_price: 1.29,',
' close_price: 1.30'
]
end
it 'does not autocorrect correct source' do
expect(autocorrect_source(cop, correct_source))
.to eq(correct_source.join("\n"))
end
it 'autocorrects by outdenting when indented too far' do
original_source = [
'create :transaction, :closed,',
' account: account,',
' open_price: 1.29,',
' close_price: 1.30'
]
expect(autocorrect_source(cop, original_source))
.to eq(correct_source.join("\n"))
end
it 'autocorrects by indenting when not indented' do
original_source = [
'create :transaction, :closed,',
'account: account,',
'open_price: 1.29,',
'close_price: 1.30'
]
expect(autocorrect_source(cop, original_source))
.to eq(correct_source.join("\n"))
end
it 'autocorrects when first line is indented' do
original_source = [
' create :transaction, :closed,',
' account: account,',
' open_price: 1.29,',
' close_price: 1.30'
]
correct_source = [
' create :transaction, :closed,',
' account: account,',
' open_price: 1.29,',
' close_price: 1.30'
]
expect(autocorrect_source(cop, original_source))
.to eq(correct_source.join("\n"))
end
context 'multi-line method calls' do
it 'can handle existing indentation from multi-line method calls' do
inspect_source(cop, [' something',
' .method_name(',
' a,',
' b,',
' c',
' )'])
expect(cop.offenses).to be_empty
end
it 'registers offenses for double indentation from relevant method' do
inspect_source(cop, [' something',
' .method_name(',
' a,',
' b,',
' c',
' )'])
expect(cop.offenses.size).to eq(3)
end
it 'does not err on method call without a method name' do
inspect_source(cop, [' something',
' .(',
' a,',
' b,',
' c',
' )'])
expect(cop.offenses).to be_empty
end
it 'autocorrects relative to position of relevant method call' do
original_source = [
' something',
' .method_name(',
' a,',
' b,',
' c',
' )'
]
correct_source = [
' something',
' .method_name(',
' a,',
' b,',
' c',
' )'
]
expect(autocorrect_source(cop, original_source))
.to eq(correct_source.join("\n"))
end
end
context 'method definitions' do
it 'registers an offense for parameters aligned to first param' do
inspect_source(cop, ['def method(a,',
' b)',
'end'])
expect(cop.offenses.size).to eq 1
expect(cop.messages)
.to eq(['Use one level of indentation for parameters ' \
'following the first line of a multi-line method ' \
'definition.'])
end
it 'registers an offense for parameters with double indent' do
inspect_source(cop, ['def method(a,',
' b)',
'end'])
expect(cop.offenses.size).to eq 1
end
it 'accepts parameter lists on a single line' do
inspect_source(cop, ['def method(a, b)',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts proper indentation' do
inspect_source(cop, ['def method(a,',
' b)',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts the first parameter being on a new row' do
inspect_source(cop, ['def method(',
' a,',
' b)',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts a method definition without parameters' do
inspect_source(cop, ['def method',
'end'])
expect(cop.offenses).to be_empty
end
it "doesn't get confused by splat" do
inspect_source(cop, ['def func2(a,',
' *b,',
' c)',
'end'])
expect(cop.offenses).not_to be_empty
expect(cop.highlights).to include '*b'
end
it 'auto-corrects alignment' do
new_source = autocorrect_source(cop, ['def method(a,',
' b)',
'end'])
expect(new_source).to eq(['def method(a,',
' b)',
'end'].join("\n"))
end
context 'defining self.method' do
it 'registers an offense for parameters aligned to first param' do
inspect_source(cop, ['def self.method(a,',
' b)',
'end'])
expect(cop.offenses.size).to eq 1
expect(cop.offenses.first.to_s).to match(/method definition/)
end
it 'accepts proper indentation' do
inspect_source(cop, ['def self.method(a,',
' b)',
'end'])
expect(cop.offenses).to be_empty
end
it 'auto-corrects alignment' do
new_source = autocorrect_source(cop, ['def self.method(a,',
' b)',
'end'])
expect(new_source).to eq(['def self.method(a,',
' b)',
'end'].join("\n"))
end
end
end
context 'assigned methods' do
context 'with IndentationWidth:Width set to 4' do
let(:indentation_width) { 4 }
it 'accepts the first parameter being on a new row' do
inspect_source(cop, [' assigned_value = match(',
' a,',
' b,',
' c',
' )'])
expect(cop.offenses).to be_empty
end
it 'accepts the first parameter being on method row' do
inspect_source(cop, [' assigned_value = match(a,',
' b,',
' c',
' )'])
expect(cop.offenses).to be_empty
end
it 'autocorrects even when first argument is in wrong position' do
original_source = [' assigned_value = match(',
' a,',
' b,',
' c',
' )']
correct_source = [' assigned_value = match(',
' a,',
' b,',
' c',
' )']
expect(autocorrect_source(cop, original_source))
.to eq(correct_source.join("\n"))
end
end
context 'with AlignParameters:IndentationWidth set to 4' do
let(:config) do
RuboCop::Config.new('Style/AlignParameters' =>
cop_config.merge('IndentationWidth' => 4))
end
it 'accepts the first parameter being on a new row' do
inspect_source(cop, [' assigned_value = match(',
' a,',
' b,',
' c',
' )'])
expect(cop.offenses).to be_empty
end
it 'accepts the first parameter being on method row' do
inspect_source(cop, [' assigned_value = match(a,',
' b,',
' c',
' )'])
expect(cop.offenses).to be_empty
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/and_or_spec.rb 0000664 0000000 0000000 00000032511 13070542236 0024264 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::AndOr, :config do
context 'when style is conditionals' do
cop_config = {
'EnforcedStyle' => 'conditionals'
}
subject(:cop) { described_class.new(config) }
let(:cop_config) { cop_config }
%w[and or].each do |operator|
it "accepts \"#{operator}\" outside of conditional" do
inspect_source(cop, "x = a + b #{operator} return x")
expect(cop.offenses).to be_empty
end
{
'if' => 'if %{conditional}; %{body}; end',
'while' => 'while %{conditional}; %{body}; end',
'until' => 'until %{conditional}; %{body}; end',
'post-conditional while' => 'begin; %{body}; end while %{conditional}',
'post-conditional until' => 'begin; %{body}; end until %{conditional}'
}.each do |type, snippet_format|
it "registers an offense for \"#{operator}\" in #{type} conditional" do
elements = {
conditional: "a #{operator} b",
body: 'do_something'
}
source = format(snippet_format, elements)
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it "accepts \"#{operator}\" in #{type} body" do
elements = {
conditional: 'some_condition',
body: "do_something #{operator} return"
}
source = format(snippet_format, elements)
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
%w[&& ||].each do |operator|
it "accepts #{operator} inside of conditional" do
inspect_source(cop, "test if a #{operator} b")
expect(cop.offenses).to be_empty
end
it "accepts #{operator} outside of conditional" do
inspect_source(cop, "x = a #{operator} b")
expect(cop.offenses).to be_empty
end
end
end
context 'when style is always' do
cop_config = {
'EnforcedStyle' => 'always'
}
subject(:cop) { described_class.new(config) }
let(:cop_config) { cop_config }
it 'registers an offense for "or"' do
inspect_source(cop, 'test if a or b')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Use `||` instead of `or`.'])
end
it 'registers an offense for "and"' do
inspect_source(cop, 'test if a and b')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Use `&&` instead of `and`.'])
end
it 'accepts ||' do
inspect_source(cop, 'test if a || b')
expect(cop.offenses).to be_empty
end
it 'accepts &&' do
inspect_source(cop, 'test if a && b')
expect(cop.offenses).to be_empty
end
it 'auto-corrects "and" with &&' do
new_source = autocorrect_source(cop, 'true and false')
expect(new_source).to eq('true && false')
end
it 'auto-corrects "or" with ||' do
new_source = autocorrect_source(cop, ['x = 12345',
'true or false'])
expect(new_source).to eq(['x = 12345',
'true || false'].join("\n"))
end
it 'auto-corrects "or" with || inside def' do
new_source = autocorrect_source(cop, ['def z(a, b)',
' return true if a or b',
'end'])
expect(new_source).to eq(['def z(a, b)',
' return true if a || b',
'end'].join("\n"))
end
it 'autocorrects "or" with an assignment on the left' do
src = "x = y or teststring.include? 'b'"
new_source = autocorrect_source(cop, src)
expect(new_source).to eq("(x = y) || teststring.include?('b')")
end
it 'autocorrects "or" with an assignment on the right' do
src = "teststring.include? 'b' or x = y"
new_source = autocorrect_source(cop, src)
expect(new_source).to eq("teststring.include?('b') || (x = y)")
end
it 'autocorrects "and" with an assignment and return on either side' do
src = 'x = a + b and return x'
new_source = autocorrect_source(cop, src)
expect(new_source).to eq('(x = a + b) && (return x)')
end
it 'warns on short-circuit (and)' do
inspect_source(cop, 'x = a + b and return x')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Use `&&` instead of `and`.'])
end
it 'also warns on non short-circuit (and)' do
inspect_source(cop, 'x = a + b if a and b')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Use `&&` instead of `and`.'])
end
it 'also warns on non short-circuit (and) (unless)' do
inspect_source(cop, 'x = a + b unless a and b')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Use `&&` instead of `and`.'])
end
it 'warns on short-circuit (or)' do
inspect_source(cop, 'x = a + b or return x')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Use `||` instead of `or`.'])
end
it 'also warns on non short-circuit (or)' do
inspect_source(cop, 'x = a + b if a or b')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Use `||` instead of `or`.'])
end
it 'also warns on non short-circuit (or) (unless)' do
inspect_source(cop, 'x = a + b unless a or b')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Use `||` instead of `or`.'])
end
it 'also warns on while (or)' do
inspect_source(cop, 'x = a + b while a or b')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Use `||` instead of `or`.'])
end
it 'also warns on until (or)' do
inspect_source(cop, 'x = a + b until a or b')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Use `||` instead of `or`.'])
end
it 'auto-corrects "or" with || in method calls' do
new_source = autocorrect_source(cop, 'method a or b')
expect(new_source).to eq('method(a) || b')
end
it 'auto-corrects "or" with || in method calls (2)' do
new_source = autocorrect_source(cop, 'method a,b or b')
expect(new_source).to eq('method(a,b) || b')
end
it 'auto-corrects "or" with || in method calls (3)' do
new_source = autocorrect_source(cop, 'obj.method a or b')
expect(new_source).to eq('obj.method(a) || b')
end
it 'auto-corrects "or" with || in method calls (4)' do
new_source = autocorrect_source(cop, 'obj.method a,b or b')
expect(new_source).to eq('obj.method(a,b) || b')
end
it 'auto-corrects "or" with || and doesn\'t add extra parentheses' do
new_source = autocorrect_source(cop, 'method(a, b) or b')
expect(new_source).to eq('method(a, b) || b')
end
it 'auto-corrects "or" with || and adds parentheses to expr' do
new_source = autocorrect_source(cop, 'b or method a,b')
expect(new_source).to eq('b || method(a,b)')
end
it 'auto-corrects "and" with && in method calls' do
new_source = autocorrect_source(cop, 'method a and b')
expect(new_source).to eq('method(a) && b')
end
it 'auto-corrects "and" with && in method calls (2)' do
new_source = autocorrect_source(cop, 'method a,b and b')
expect(new_source).to eq('method(a,b) && b')
end
it 'auto-corrects "and" with && in method calls (3)' do
new_source = autocorrect_source(cop, 'obj.method a and b')
expect(new_source).to eq('obj.method(a) && b')
end
it 'auto-corrects "and" with && in method calls (4)' do
new_source = autocorrect_source(cop, 'obj.method a,b and b')
expect(new_source).to eq('obj.method(a,b) && b')
end
it 'auto-corrects "and" with && and doesn\'t add extra parentheses' do
new_source = autocorrect_source(cop, 'method(a, b) and b')
expect(new_source).to eq('method(a, b) && b')
end
it 'auto-corrects "and" with && and adds parentheses to expr' do
new_source = autocorrect_source(cop, 'b and method a,b')
expect(new_source).to eq('b && method(a,b)')
end
context 'with !obj.method arg on right' do
it 'autocorrects "and" with && and adds parens' do
new_source = autocorrect_source(cop, 'x and !obj.method arg')
expect(new_source).to eq('x && !obj.method(arg)')
end
end
context 'with !obj.method arg on left' do
it 'autocorrects "and" with && and adds parens' do
new_source = autocorrect_source(cop, '!obj.method arg and x')
expect(new_source).to eq('!obj.method(arg) && x')
end
end
context 'with obj.method = arg on left' do
it 'autocorrects "and" with && and adds parens' do
new_source = autocorrect_source(cop, 'obj.method = arg and x')
expect(new_source).to eq('(obj.method = arg) && x')
end
end
context 'with obj.method= arg on left' do
it 'autocorrects "and" with && and adds parens' do
new_source = autocorrect_source(cop, 'obj.method= arg and x')
expect(new_source).to eq('(obj.method= arg) && x')
end
end
context 'with predicate method with arg without space on right' do
it 'autocorrects "or" with || and adds parens' do
new_source = autocorrect_source(cop, 'false or 3.is_a?Integer')
expect(new_source).to eq('false || 3.is_a?(Integer)')
end
it 'autocorrects "and" with && and adds parens' do
new_source = autocorrect_source(cop, 'false and 3.is_a?Integer')
expect(new_source).to eq('false && 3.is_a?(Integer)')
end
end
context 'with two predicate methods with args without spaces on right' do
it 'autocorrects "or" with || and adds parens' do
new_source = autocorrect_source(cop, "'1'.is_a?Integer " \
'or 1.is_a?Integer')
expect(new_source).to eq('\'1\'.is_a?(Integer) || 1.is_a?(Integer)')
end
it 'autocorrects "and" with && and adds parens' do
new_source = autocorrect_source(cop, "'1'.is_a?Integer and" \
' 1.is_a?Integer')
expect(new_source).to eq('\'1\'.is_a?(Integer) && 1.is_a?(Integer)')
end
end
context 'with one predicate method without space on right and another ' \
'method' do
it 'autocorrects "or" with || and adds parens' do
new_source = autocorrect_source(cop, "'1'.is_a?Integer or" \
' 1.is_a? Integer')
expect(new_source).to eq("'1'.is_a?(Integer) || 1.is_a?(Integer)")
end
it 'autocorrects "and" with && and adds parens' do
new_source = autocorrect_source(cop, "'1'.is_a?Integer " \
'and 1.is_a? Integer')
expect(new_source).to eq('\'1\'.is_a?(Integer) && 1.is_a?(Integer)')
end
end
context 'with `not` expression on right' do
it 'autocorrects "and" with && and adds parens' do
new_source = autocorrect_source(cop, 'x and not arg')
expect(new_source).to eq('x && (not arg)')
end
end
context 'with `not` expression on left' do
it 'autocorrects "and" with && and adds parens' do
new_source = autocorrect_source(cop, 'not arg and x')
expect(new_source).to eq('(not arg) && x')
end
end
context 'with !variable on left' do
it "doesn't crash and burn" do
# regression test; see GH issue 2482
inspect_source(cop, '!var or var.empty?')
expect(cop.offenses.size).to eq(1)
end
end
context 'within a nested begin node' do
# regression test; see GH issue 2531
it 'autocorrects "and" with && and adds parens' do
new_source = autocorrect_source(cop, ['def x',
'end',
'',
'def y',
' a = b and a.c',
'end'])
expect(new_source).to eq(['def x',
'end',
'',
'def y',
' (a = b) && a.c',
'end'].join("\n"))
end
end
context 'within a nested begin node with one child only' do
# regression test; see GH issue 2531
it 'autocorrects "and" with && and adds parens' do
new_source = autocorrect_source(cop, ['(def y',
' a = b and a.c',
'end)'])
expect(new_source).to eq(['(def y',
' (a = b) && a.c',
'end)'].join("\n"))
end
end
context 'with a file which contains __FILE__' do
let(:source) do
["APP_ROOT = Pathname.new File.expand_path('../../', __FILE__)",
"system('bundle check') or system!('bundle install')"]
end
# regression test; see GH issue 2609
it 'autocorrects "or" with ||' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(
["APP_ROOT = Pathname.new File.expand_path('../../', __FILE__)",
"system('bundle check') || system!('bundle install')"].join("\n")
)
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/array_join_spec.rb 0000664 0000000 0000000 00000002613 13070542236 0025157 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::ArrayJoin do
subject(:cop) { described_class.new }
it 'registers an offense for an array followed by string' do
inspect_source(cop,
'%w(one two three) * ", "')
expect(cop.offenses.size).to eq(1)
end
it "autocorrects '*' to 'join' when there are spaces" do
corrected =
autocorrect_source(cop,
'%w(one two three) * ", "')
expect(corrected).to eq '%w(one two three).join(", ")'
end
it "autocorrects '*' to 'join' when there are no spaces" do
corrected =
autocorrect_source(cop,
'%w(one two three)*", "')
expect(corrected).to eq '%w(one two three).join(", ")'
end
it "autocorrects '*' to 'join' when setting to a variable" do
corrected =
autocorrect_source(cop,
'foo = %w(one two three)*", "')
expect(corrected).to eq 'foo = %w(one two three).join(", ")'
end
it 'does not register an offense for numbers' do
inspect_source(cop,
'%w(one two three) * 4')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for ambiguous cases' do
inspect_source(cop,
'test * ", "')
expect(cop.offenses).to be_empty
inspect_source(cop,
'%w(one two three) * test')
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/ascii_comments_spec.rb 0000664 0000000 0000000 00000001660 13070542236 0026020 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::AsciiComments do
subject(:cop) { described_class.new }
it 'registers an offense for a comment with non-ascii chars' do
inspect_source(cop,
['# encoding: utf-8',
'# 这是什么？'])
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['这是什么？'])
expect(cop.messages)
.to eq(['Use only ascii symbols in comments.'])
end
it 'registers an offense for commentes with mixed chars' do
inspect_source(cop,
['# encoding: utf-8',
'# foo ∂ bar'])
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['∂'])
expect(cop.messages)
.to eq(['Use only ascii symbols in comments.'])
end
it 'accepts comments with only ascii chars' do
inspect_source(cop, '# AZaz1@$%~,;*_`|')
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/ascii_identifiers_spec.rb 0000664 0000000 0000000 00000002464 13070542236 0026503 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::AsciiIdentifiers do
subject(:cop) { described_class.new }
it 'registers an offense for a variable name with non-ascii chars' do
inspect_source(cop,
['# encoding: utf-8',
'älg = 1'])
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['ä'])
expect(cop.messages)
.to eq(['Use only ascii symbols in identifiers.'])
end
it 'registers an offense for a variable name with mixed chars' do
inspect_source(cop,
['# encoding: utf-8',
'foo∂∂bar = baz'])
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['∂∂'])
expect(cop.messages)
.to eq(['Use only ascii symbols in identifiers.'])
end
it 'accepts identifiers with only ascii chars' do
inspect_source(cop,
'x.empty?')
expect(cop.offenses).to be_empty
end
it 'does not get confused by a byte order mark' do
bom = "\xef\xbb\xbf"
inspect_source(cop,
[bom + '# encoding: utf-8',
"puts 'foo'"])
expect(cop.offenses).to be_empty
end
it 'does not get confused by an empty file' do
inspect_source(cop,
'')
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/attr_spec.rb 0000664 0000000 0000000 00000004176 13070542236 0024002 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::Attr do
subject(:cop) { described_class.new }
it 'registers an offense attr' do
inspect_source(cop, ['class SomeClass',
' attr :name',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'accepts attr when it does not take arguments' do
inspect_source(cop, 'func(attr)')
expect(cop.offenses).to be_empty
end
it 'accepts attr when it has a receiver' do
inspect_source(cop, 'x.attr arg')
expect(cop.offenses).to be_empty
end
context 'auto-corrects' do
it 'attr to attr_reader' do
new_source = autocorrect_source(cop, 'attr :name')
expect(new_source).to eq('attr_reader :name')
end
it 'attr, false to attr_reader' do
new_source = autocorrect_source(cop, 'attr :name, false')
expect(new_source).to eq('attr_reader :name')
end
it 'attr :name, true to attr_accessor :name' do
new_source = autocorrect_source(cop, 'attr :name, true')
expect(new_source).to eq('attr_accessor :name')
end
it 'attr with multiple names to attr_reader' do
new_source = autocorrect_source(cop, 'attr :foo, :bar')
expect(new_source).to eq('attr_reader :foo, :bar')
end
end
context 'offense message' do
let(:msg_reader) { 'Do not use `attr`. Use `attr_reader` instead.' }
let(:msg_accessor) { 'Do not use `attr`. Use `attr_accessor` instead.' }
it 'for attr :name suggests to use attr_reader' do
inspect_source(cop, 'attr :name')
expect(cop.offenses.first.message).to eq(msg_reader)
end
it 'for attr :name, false suggests to use attr_reader' do
inspect_source(cop, 'attr :name, false')
expect(cop.offenses.first.message).to eq(msg_reader)
end
it 'for attr :name, true suggests to use attr_accessor' do
inspect_source(cop, 'attr :name, true')
expect(cop.offenses.first.message).to eq(msg_accessor)
end
it 'for attr with multiple names suggests to use attr_reader' do
inspect_source(cop, 'attr :foo, :bar')
expect(cop.offenses.first.message).to eq(msg_reader)
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/auto_resource_cleanup_spec.rb 0000664 0000000 0000000 00000001267 13070542236 0027414 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::AutoResourceCleanup do
subject(:cop) { described_class.new }
it 'registers an offense for File.open without block' do
inspect_source(cop, 'File.open("filename")')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Use the block version of `File.open`.'])
end
it 'does not register an offense for File.open with block' do
inspect_source(cop, 'File.open("file") { |f| something }')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for File.open with block-pass' do
inspect_source(cop, 'File.open("file", &:read)')
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/bare_percent_literals_spec.rb 0000664 0000000 0000000 00000006572 13070542236 0027362 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::BarePercentLiterals, :config do
subject(:cop) { described_class.new(config) }
shared_examples 'accepts other delimiters' do
it 'accepts __FILE__' do
inspect_source(cop, '__FILE__')
expect(cop.offenses).to be_empty
end
it 'accepts regular expressions' do
inspect_source(cop, '/%Q?/')
expect(cop.offenses).to be_empty
end
it 'accepts ""' do
inspect_source(cop, '""')
expect(cop.offenses).to be_empty
end
it 'accepts "" string with interpolation' do
inspect_source(cop, '"#{file}hi"')
expect(cop.offenses).to be_empty
end
it "accepts ''" do
inspect_source(cop, "'hi'")
expect(cop.offenses).to be_empty
end
it 'accepts %q' do
inspect_source(cop, '%q(hi)')
expect(cop.offenses).to be_empty
end
it 'accepts heredoc' do
inspect_source(cop, ['func < 'percent_q' } }
context 'and strings are static' do
it 'registers an offense for %()' do
inspect_source(cop, '%(hi)')
expect(cop.messages).to eq(['Use `%Q` instead of `%`.'])
expect(cop.highlights).to eq(['%('])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, '%(hi)')
expect(new_source).to eq('%Q(hi)')
end
it 'accepts %Q()' do
inspect_source(cop, '%Q(hi)')
expect(cop.offenses).to be_empty
end
include_examples 'accepts other delimiters'
end
context 'and strings are dynamic' do
it 'registers an offense for %()' do
inspect_source(cop, '%(#{x})')
expect(cop.messages).to eq(['Use `%Q` instead of `%`.'])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, '%(#{x})')
expect(new_source).to eq('%Q(#{x})')
end
it 'accepts %Q()' do
inspect_source(cop, '%Q(#{x})')
expect(cop.offenses).to be_empty
end
include_examples 'accepts other delimiters'
end
end
context 'when EnforcedStyle is bare_percent' do
let(:cop_config) { { 'EnforcedStyle' => 'bare_percent' } }
context 'and strings are static' do
it 'registers an offense for %Q()' do
inspect_source(cop, '%Q(hi)')
expect(cop.messages).to eq(['Use `%` instead of `%Q`.'])
expect(cop.highlights).to eq(['%Q('])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, '%Q(hi)')
expect(new_source).to eq('%(hi)')
end
it 'accepts %()' do
inspect_source(cop, '%(hi)')
expect(cop.offenses).to be_empty
end
include_examples 'accepts other delimiters'
end
context 'and strings are dynamic' do
it 'registers an offense for %Q()' do
inspect_source(cop, '%Q(#{x})')
expect(cop.messages).to eq(['Use `%` instead of `%Q`.'])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, '%Q(#{x})')
expect(new_source).to eq('%(#{x})')
end
it 'accepts %()' do
inspect_source(cop, '%(#{x})')
expect(cop.offenses).to be_empty
end
include_examples 'accepts other delimiters'
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/begin_block_spec.rb 0000664 0000000 0000000 00000000414 13070542236 0025255 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::BeginBlock do
subject(:cop) { described_class.new }
it 'reports an offense for a BEGIN block' do
src = 'BEGIN { test }'
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/block_comments_spec.rb 0000664 0000000 0000000 00000002731 13070542236 0026022 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::BlockComments do
subject(:cop) { described_class.new }
it 'registers an offense for block comments' do
inspect_source(cop,
['=begin',
'comment',
'=end'])
expect(cop.offenses.size).to eq(1)
end
it 'accepts regular comments' do
inspect_source(cop,
'# comment')
expect(cop.offenses).to be_empty
end
it 'auto-corrects a block comment into a regular comment' do
new_source = autocorrect_source(cop, ['=begin',
'comment line 1',
'',
'comment line 2',
'=end',
'def foo',
'end'])
expect(new_source).to eq(['# comment line 1',
'#',
'# comment line 2',
'def foo',
'end'].join("\n"))
end
it 'auto-corrects an empty block comment by removing it' do
new_source = autocorrect_source(cop, ['=begin',
'=end',
'def foo',
'end'])
expect(new_source).to eq(['def foo',
'end'].join("\n"))
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/block_delimiters_spec.rb 0000664 0000000 0000000 00000033343 13070542236 0026341 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::BlockDelimiters, :config do
subject(:cop) { described_class.new(config) }
shared_examples 'syntactic styles' do
it 'registers an offense for a single line block with do-end' do
inspect_source(cop, 'each do |x| end')
expect(cop.messages)
.to eq(['Prefer `{...}` over `do...end` for single-line blocks.'])
end
it 'accepts a single line block with braces' do
inspect_source(cop, 'each { |x| }')
expect(cop.offenses).to be_empty
end
it 'accepts a multi-line block with do-end' do
inspect_source(cop, ['each do |x|',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts a multi-line block that needs braces to be valid ruby' do
inspect_source(cop, ['puts [1, 2, 3].map { |n|',
' n * n',
'}, 1'])
expect(cop.messages).to be_empty
end
end
context 'Semantic style' do
cop_config = {
'EnforcedStyle' => 'semantic',
'ProceduralMethods' => %w[tap],
'FunctionalMethods' => %w[let],
'IgnoredMethods' => %w[lambda]
}
let(:cop_config) { cop_config }
it 'accepts a multi-line block with braces if the return value is ' \
'assigned' do
inspect_source(cop, ['foo = map { |x|',
' x',
'}'])
expect(cop.offenses).to be_empty
end
it 'accepts a multi-line block with braces if it is the return value ' \
'of its scope' do
inspect_source(cop, ['block do',
' map { |x|',
' x',
' }',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts a multi-line block with braces when passed to a method' do
inspect_source(cop, ['puts map { |x|',
' x',
'}'])
expect(cop.offenses).to be_empty
end
it 'accepts a multi-line block with braces when chained' do
inspect_source(cop, ['map { |x|',
' x',
'}.inspect'])
expect(cop.offenses).to be_empty
end
it 'accepts a multi-line block with braces when passed to a known ' \
'functional method' do
inspect_source(cop, ['let(:foo) {',
' x',
'}'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for a multi-line block with braces if the ' \
'return value is not used' do
inspect_source(cop, ['each { |x|',
' x',
'}'])
expect(cop.messages)
.to eq(['Prefer `do...end` over `{...}` for procedural blocks.'])
end
it 'registers an offense for a multi-line block with do-end if the ' \
'return value is assigned' do
inspect_source(cop, ['foo = map do |x|',
' x',
'end'])
expect(cop.messages)
.to eq(['Prefer `{...}` over `do...end` for functional blocks.'])
end
it 'registers an offense for a multi-line block with do-end if the ' \
'return value is passed to a method' do
inspect_source(cop, ['puts (map do |x|',
' x',
'end)'])
expect(cop.messages)
.to eq(['Prefer `{...}` over `do...end` for functional blocks.'])
end
it 'accepts a multi-line block with do-end if it is the return value ' \
'of its scope' do
inspect_source(cop, ['block do',
' map do |x|',
' x',
' end',
'end'])
expect(cop.messages).to be_empty
end
it 'accepts a single line block with {} if used in an if statement' do
inspect_source(cop, 'return if any? { |x| x }')
expect(cop.messages).to be_empty
end
it 'accepts a single line block with {} if used in a logical or' do
inspect_source(cop, 'any? { |c| c } || foo')
expect(cop.messages).to be_empty
end
it 'accepts a single line block with {} if used in a logical and' do
inspect_source(cop, 'any? { |c| c } && foo')
expect(cop.messages).to be_empty
end
it 'accepts a single line block with {} if used in an array' do
inspect_source(cop, '[detect { true }, other]')
expect(cop.messages).to be_empty
end
it 'accepts a single line block with {} if used in an irange' do
inspect_source(cop, 'detect { true }..other')
expect(cop.messages).to be_empty
end
it 'accepts a single line block with {} if used in an erange' do
inspect_source(cop, 'detect { true }...other')
expect(cop.messages).to be_empty
end
it 'accepts a multi-line functional block with do-end if it is ' \
'a known procedural method' do
inspect_source(cop, ['foo = bar.tap do |x|',
' x.age = 3',
'end'])
expect(cop.messages).to be_empty
end
it 'accepts a multi-line functional block with do-end if it is ' \
'an ignored method' do
inspect_source(cop, ['foo = lambda do',
' puts 42',
'end'])
expect(cop.messages).to be_empty
end
it 'registers an offense for a single line procedural block' do
inspect_source(cop, 'each { |x| puts x }')
expect(cop.messages)
.to eq(['Prefer `do...end` over `{...}` for procedural blocks.'])
end
it 'accepts a single line block with do-end if it is procedural' do
inspect_source(cop, 'each do |x| puts x; end')
expect(cop.messages).to be_empty
end
context 'with a procedural block' do
let(:corrected_source) do
<<-END.strip_indent
each do |x|
x
end
END
end
it 'auto-corrects { and } to do and end' do
source = <<-END.strip_indent
each { |x|
x
}
END
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(corrected_source)
end
it 'auto-corrects { and } to do and end with appropriate spacing' do
source = <<-END.strip_indent
each {|x|
x
}
END
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(corrected_source)
end
end
it 'does not auto-correct {} to do-end if it is a known functional ' \
'method' do
source = <<-END.strip_indent
let(:foo) { |x|
x
}
END
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
it 'does not autocorrect do-end to {} if it is a known procedural ' \
'method' do
source = <<-END.strip_indent
foo = bar.tap do |x|
x.age = 1
end
END
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
it 'auto-corrects do-end to {} if it is a functional block' do
source = <<-END.strip_indent
foo = map do |x|
x
end
END
expected_source = <<-END.strip_indent
foo = map { |x|
x
}
END
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(expected_source)
end
it 'auto-corrects do-end to {} with appropriate spacing' do
source = <<-END.strip_indent
foo = map do|x|
x
end
END
expected_source = <<-END.strip_indent
foo = map { |x|
x
}
END
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(expected_source)
end
it 'auto-corrects do-end to {} if it is a functional block and does ' \
'not change the meaning' do
source = <<-END.strip_indent
puts (map do |x|
x
end)
END
expected_source = <<-END.strip_indent
puts (map { |x|
x
})
END
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(expected_source)
end
end
context 'line count-based style' do
cop_config = {
'EnforcedStyle' => 'line_count_based',
'IgnoredMethods' => %w[proc]
}
let(:cop_config) { cop_config }
include_examples 'syntactic styles'
it 'auto-corrects do and end for single line blocks to { and }' do
new_source = autocorrect_source(cop, 'block do |x| end')
expect(new_source).to eq('block { |x| }')
end
it 'does not auto-correct do-end if {} would change the meaning' do
src = "s.subspec 'Subspec' do |sp| end"
new_source = autocorrect_source(cop, src)
expect(new_source).to eq(src)
end
it 'does not auto-correct {} if do-end would change the meaning' do
src = ['foo :bar, :baz, qux: lambda { |a|',
' bar a',
'}'].join("\n")
new_source = autocorrect_source(cop, src)
expect(new_source).to eq(src)
end
context 'when there are braces around a multi-line block' do
it 'registers an offense in the simple case' do
inspect_source(cop, ['each { |x|',
'}'])
expect(cop.messages)
.to eq(['Avoid using `{...}` for multi-line blocks.'])
end
it 'accepts braces if do-end would change the meaning' do
src = ['scope :foo, lambda { |f|',
' where(condition: "value")',
'}',
'',
'expect { something }.to raise_error(ErrorClass) { |error|',
' # ...',
'}',
'',
'expect { x }.to change {',
' Counter.count',
'}.from(0).to(1)',
'',
'cr.stubs client: mock {',
' expects(:email_disabled=).with(true)',
' expects :save',
'}']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'accepts a multi-line functional block with {} if it is ' \
'an ignored method' do
inspect_source(cop, ['foo = proc {',
' puts 42',
'}'])
expect(cop.messages).to be_empty
end
it 'registers an offense for braces if do-end would not change ' \
'the meaning' do
src = ['scope :foo, (lambda { |f|',
' where(condition: "value")',
'})',
'',
'expect { something }.to(raise_error(ErrorClass) { |error|',
' # ...',
'})']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(2)
end
it 'can handle special method names such as []= and done?' do
src = ['h2[k2] = Hash.new { |h3,k3|',
' h3[k3] = 0',
'}',
'',
'x = done? list.reject { |e|',
' e.nil?',
'}']
inspect_source(cop, src)
expect(cop.messages)
.to eq(['Avoid using `{...}` for multi-line blocks.'])
end
it 'auto-corrects { and } to do and end' do
source = <<-END.strip_indent
each{ |x|
some_method
other_method
}
END
expected_source = <<-END.strip_indent
each do |x|
some_method
other_method
end
END
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(expected_source)
end
it 'auto-corrects adjacent curly braces correctly' do
source = ['(0..3).each { |a| a.times {',
' puts a',
'}}']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['(0..3).each do |a| a.times do',
' puts a',
'end end'].join("\n"))
end
it 'does not auto-correct {} if do-end would introduce a syntax error' do
src = ['my_method :arg1, arg2: proc {',
' something',
'}, arg3: :another_value'].join("\n")
new_source = autocorrect_source(cop, src)
expect(new_source).to eq(src)
end
end
end
context 'braces for chaining style' do
cop_config = {
'EnforcedStyle' => 'braces_for_chaining',
'IgnoredMethods' => %w[proc]
}
let(:cop_config) { cop_config }
include_examples 'syntactic styles'
it 'registers an offense for multi-line chained do-end blocks' do
inspect_source(cop, ['each do |x|',
'end.map(&:to_s)'])
expect(cop.messages).to eq(
['Prefer `{...}` over `do...end` for multi-line chained blocks.']
)
end
it 'auto-corrects do-end for chained blocks' do
src = ['each do |x|',
'end.map(&:to_s)']
new_source = autocorrect_source(cop, src)
expect(new_source).to eq("each { |x|\n}.map(&:to_s)")
end
it 'accepts a multi-line functional block with {} if it is ' \
'an ignored method' do
inspect_source(cop, ['foo = proc {',
' puts 42',
'}'])
expect(cop.messages).to be_empty
end
context 'when there are braces around a multi-line block' do
it 'registers an offense in the simple case' do
inspect_source(cop, ['each { |x|',
'}'])
expect(cop.messages)
.to eq(['Prefer `do...end` for multi-line blocks without chaining.'])
end
it 'allows when the block is being chained' do
inspect_source(cop, ['each { |x|',
'}.map(&:to_sym)'])
expect(cop.offenses).to be_empty
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/block_end_newline_spec.rb 0000664 0000000 0000000 00000003153 13070542236 0026463 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::BlockEndNewline do
subject(:cop) { described_class.new }
it 'does not register an offense for a one-liner' do
inspect_source(cop, 'test do foo end')
expect(cop.messages).to be_empty
end
it 'does not register an offense for multiline blocks with newlines before '\
'the end' do
inspect_source(cop,
['test do',
' foo',
'end'])
expect(cop.messages).to be_empty
end
it 'registers an offense when multiline block end is not on its own line' do
inspect_source(cop,
['test do',
' foo end'])
expect(cop.messages)
.to eq(['Expression at 2, 7 should be on its own line.'])
end
it 'registers an offense when multiline block } is not on its own line' do
inspect_source(cop,
['test {',
' foo }'])
expect(cop.messages)
.to eq(['Expression at 2, 7 should be on its own line.'])
end
it 'autocorrects a do/end block where the end is not on its own line' do
src = ['test do',
' foo end']
new_source = autocorrect_source(cop, src)
expect(new_source).to eq(['test do',
' foo ',
'end'].join("\n"))
end
it 'autocorrects a {} block where the } is not on its own line' do
src = ['test {',
' foo }']
new_source = autocorrect_source(cop, src)
expect(new_source).to eq(['test {',
' foo ',
'}'].join("\n"))
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/braces_around_hash_parameters_spec.rb 0000664 0000000 0000000 00000024532 13070542236 0031063 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::BracesAroundHashParameters, :config do
subject(:cop) { described_class.new(config) }
shared_examples 'general non-offenses' do
after { expect(cop.offenses).to be_empty }
it 'accepts one non-hash parameter' do
inspect_source(cop, 'where(2)')
end
it 'accepts multiple non-hash parameters' do
inspect_source(cop, 'where(1, "2")')
end
it 'accepts one empty hash parameter' do
inspect_source(cop, 'where({})')
end
it 'accepts one empty hash parameter with whitespace' do
inspect_source(cop, ['where( { ',
" }\t ) "])
end
end
shared_examples 'no_braces and context_dependent non-offenses' do
after { expect(cop.offenses).to be_empty }
it 'accepts one hash parameter without braces' do
inspect_source(cop, 'where(x: "y")')
end
it 'accepts one hash parameter without braces and with multiple keys' do
inspect_source(cop, 'where(x: "y", foo: "bar")')
end
it 'accepts one hash parameter without braces and with one hash value' do
inspect_source(cop, 'where(x: { "y" => "z" })')
end
it 'accepts property assignment with braces' do
inspect_source(cop, 'x.z = { y: "z" }')
end
it 'accepts operator with a hash parameter with braces' do
inspect_source(cop, 'x.z - { y: "z" }')
end
end
shared_examples 'no_braces and context_dependent offenses' do
let(:msg) { 'Redundant curly braces around a hash parameter.' }
it 'registers an offense for one non-hash parameter followed by a hash ' \
'parameter with braces' do
inspect_source(cop, 'where(1, { y: 2 })')
expect(cop.messages).to eq([msg])
expect(cop.highlights).to eq(['{ y: 2 }'])
end
it 'registers an offense for one object method hash parameter with ' \
'braces' do
inspect_source(cop, 'x.func({ y: "z" })')
expect(cop.messages).to eq([msg])
expect(cop.highlights).to eq(['{ y: "z" }'])
end
it 'registers an offense for one hash parameter with braces' do
inspect_source(cop, 'where({ x: 1 })')
expect(cop.messages).to eq([msg])
expect(cop.highlights).to eq(['{ x: 1 }'])
end
it 'registers an offense for one hash parameter with braces and ' \
'whitespace' do
inspect_source(cop, "where( \n { x: 1 } )")
expect(cop.messages).to eq([msg])
expect(cop.highlights).to eq(['{ x: 1 }'])
end
it 'registers an offense for one hash parameter with braces and multiple ' \
'keys' do
inspect_source(cop, 'where({ x: 1, foo: "bar" })')
expect(cop.messages).to eq([msg])
expect(cop.highlights).to eq(['{ x: 1, foo: "bar" }'])
end
end
shared_examples 'no_braces and context_dependent auto-corrections' do
it 'corrects one non-hash parameter followed by a hash parameter with ' \
'braces' do
corrected = autocorrect_source(cop, ['where(1, { y: 2 })'])
expect(corrected).to eq('where(1, y: 2)')
end
it 'corrects one object method hash parameter with braces' do
corrected = autocorrect_source(cop, ['x.func({ y: "z" })'])
expect(corrected).to eq('x.func(y: "z")')
end
it 'corrects one hash parameter with braces' do
corrected = autocorrect_source(cop, ['where({ x: 1 })'])
expect(corrected).to eq('where(x: 1)')
end
it 'corrects one hash parameter with braces and whitespace' do
corrected = autocorrect_source(cop, ['where( ',
' { x: 1 } )'])
expect(corrected).to eq(['where( ',
' x: 1 )'].join("\n"))
end
it 'corrects one hash parameter with braces and multiple keys' do
corrected = autocorrect_source(cop, ['where({ x: 1, foo: "bar" })'])
expect(corrected).to eq('where(x: 1, foo: "bar")')
end
it 'corrects one hash parameter with braces and extra leading whitespace' do
corrected = autocorrect_source(cop, ['where({ x: 1, y: 2 })'])
expect(corrected).to eq('where(x: 1, y: 2)')
end
it 'corrects one hash parameter with braces and extra trailing ' \
'whitespace' do
corrected = autocorrect_source(cop, ['where({ x: 1, y: 2 })'])
expect(corrected).to eq('where(x: 1, y: 2)')
end
it 'corrects one hash parameter with braces and a trailing comma' do
corrected = autocorrect_source(cop, ['where({ x: 1, y: 2, })'])
expect(corrected).to eq('where(x: 1, y: 2)')
end
it 'corrects one hash parameter with braces and trailing comma and ' \
'whitespace' do
corrected = autocorrect_source(cop, ['where({ x: 1, y: 2, })'])
expect(corrected).to eq('where(x: 1, y: 2)')
end
it 'corrects one hash parameter with braces without adding extra space' do
corrected = autocorrect_source(cop, 'get :i, { q: { x: 1 } }')
expect(corrected).to eq('get :i, q: { x: 1 }')
end
context 'with a comment following the last key-value pair' do
it 'corrects and leaves line breaks' do
src = ['r = opts.merge({',
' p1: opts[:a],',
' p2: (opts[:b] || opts[:c]) # a comment',
'})']
corrected = autocorrect_source(cop, src)
expect(corrected).to eq(['r = opts.merge(',
' p1: opts[:a],',
' p2: (opts[:b] || opts[:c]) # a comment',
')'].join("\n"))
end
end
context 'in a method call without parentheses' do
it 'corrects a hash parameter with trailing comma' do
src = 'get :i, { x: 1, }'
corrected = autocorrect_source(cop, src)
expect(corrected).to eq('get :i, x: 1')
end
end
end
context 'when EnforcedStyle is no_braces' do
let(:cop_config) { { 'EnforcedStyle' => 'no_braces' } }
context 'for correct code' do
include_examples 'general non-offenses'
include_examples 'no_braces and context_dependent non-offenses'
end
context 'for incorrect code' do
include_examples 'no_braces and context_dependent offenses'
after do
expect(cop.messages)
.to eq(['Redundant curly braces around a hash parameter.'])
end
it 'registers an offense for two hash parameters with braces' do
inspect_source(cop, 'where({ x: 1 }, { y: 2 })')
expect(cop.highlights).to eq(['{ y: 2 }'])
end
end
describe '#autocorrect' do
include_examples 'no_braces and context_dependent auto-corrections'
it 'corrects one hash parameter with braces' do
corrected = autocorrect_source(cop, ['where(1, { x: 1 })'])
expect(corrected).to eq('where(1, x: 1)')
end
it 'corrects two hash parameters with braces' do
corrected = autocorrect_source(cop, ['where(1, { x: 1 }, { y: 2 })'])
expect(corrected).to eq('where(1, { x: 1 }, y: 2)')
end
end
end
context 'when EnforcedStyle is context_dependent' do
let(:cop_config) { { 'EnforcedStyle' => 'context_dependent' } }
context 'for correct code' do
include_examples 'general non-offenses'
include_examples 'no_braces and context_dependent non-offenses'
it 'accepts two hash parameters with braces' do
inspect_source(cop, 'where({ x: 1 }, { y: 2 })')
expect(cop.offenses).to be_empty
end
end
context 'for incorrect code' do
include_examples 'no_braces and context_dependent offenses'
it 'registers an offense for one hash parameter with braces and one ' \
'without' do
inspect_source(cop, 'where({ x: 1 }, y: 2)')
expect(cop.messages)
.to eq(['Missing curly braces around a hash parameter.'])
expect(cop.highlights).to eq(['y: 2'])
end
end
describe '#autocorrect' do
include_examples 'no_braces and context_dependent auto-corrections'
it 'corrects one hash parameter with braces and one without' do
corrected = autocorrect_source(cop, ['where(1, { x: 1 }, y: 2)'])
expect(corrected).to eq('where(1, { x: 1 }, {y: 2})')
end
it 'corrects one hash parameter with braces' do
corrected = autocorrect_source(cop, ['where(1, { x: 1 })'])
expect(corrected).to eq('where(1, x: 1)')
end
end
end
context 'when EnforcedStyle is braces' do
let(:cop_config) { { 'EnforcedStyle' => 'braces' } }
context 'for correct code' do
include_examples 'general non-offenses'
after { expect(cop.offenses).to be_empty }
it 'accepts one hash parameter with braces' do
inspect_source(cop, 'where({ x: 1 })')
end
it 'accepts multiple hash parameters with braces' do
inspect_source(cop, 'where({ x: 1 }, { y: 2 })')
end
it 'accepts one hash parameter with braces and whitespace' do
inspect_source(cop, ["where( \t { x: 1 ",
' } )'])
end
end
context 'for incorrect code' do
after do
expect(cop.messages)
.to eq(['Missing curly braces around a hash parameter.'])
end
it 'registers an offense for one hash parameter without braces' do
inspect_source(cop, 'where(x: "y")')
expect(cop.highlights).to eq(['x: "y"'])
end
it 'registers an offense for one hash parameter with multiple keys and ' \
'without braces' do
inspect_source(cop, 'where(x: "y", foo: "bar")')
expect(cop.highlights).to eq(['x: "y", foo: "bar"'])
end
it 'registers an offense for one hash parameter without braces with ' \
'one hash value' do
inspect_source(cop, 'where(x: { "y" => "z" })')
expect(cop.highlights).to eq(['x: { "y" => "z" }'])
end
end
describe '#autocorrect' do
it 'corrects one hash parameter without braces' do
corrected = autocorrect_source(cop, ['where(x: "y")'])
expect(corrected).to eq('where({x: "y"})')
end
it 'corrects one hash parameter with multiple keys and without braces' do
corrected = autocorrect_source(cop, ['where(x: "y", foo: "bar")'])
expect(corrected).to eq('where({x: "y", foo: "bar"})')
end
it 'corrects one hash parameter without braces with one hash value' do
corrected = autocorrect_source(cop, ['where(x: { "y" => "z" })'])
expect(corrected).to eq('where({x: { "y" => "z" }})')
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/case_equality_spec.rb 0000664 0000000 0000000 00000000441 13070542236 0025647 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::CaseEquality do
subject(:cop) { described_class.new }
it 'registers an offense for ===' do
inspect_source(cop, 'Array === var')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['==='])
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/case_indentation_spec.rb 0000664 0000000 0000000 00000041176 13070542236 0026340 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::CaseIndentation do
subject(:cop) { described_class.new(config) }
let(:config) do
merged = RuboCop::ConfigLoader
.default_configuration['Style/CaseIndentation'].merge(cop_config)
RuboCop::Config.new('Style/CaseIndentation' => merged,
'Style/IndentationWidth' => { 'Width' => 2 })
end
context 'with EnforcedStyle: case' do
context 'with IndentOneStep: false' do
let(:cop_config) do
{ 'EnforcedStyle' => 'case', 'IndentOneStep' => false }
end
context 'with everything on a single line' do
let(:source) { 'case foo; when :bar then 1; else 0; end' }
it 'does not register an offense' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
context 'regarding assignment where the right hand side is a case' do
let(:correct_source) do
['output = case variable',
" when 'value1'",
" 'output1'",
'else',
" 'output2'",
'end']
end
let(:source) do
['output = case variable',
" when 'value1'",
" 'output1'",
' else',
" 'output2'",
' end']
end
it 'accepts a correctly indented assignment' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
context 'an assignment indented as end' do
let(:source) do
['output = case variable',
"when 'value1'",
" 'output1'",
'else',
" 'output2'",
'end']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Indent `when` as deep as `case`.'])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' =>
'end')
end
it 'does auto-correction' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq correct_source.join("\n")
end
end
context 'an assignment indented some other way' do
let(:source) do
['output = case variable',
" when 'value1'",
" 'output1'",
' else',
" 'output2'",
'end']
end
let(:correct_source) do
['output = case variable',
" when 'value1'",
" 'output1'",
' else',
" 'output2'",
'end']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Indent `when` as deep as `case`.'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'does auto-correction' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq correct_source.join("\n")
end
end
context 'correct + opposite' do
let(:source) do
['output = case variable',
" when 'value1'",
" 'output1'",
' else',
" 'output2'",
' end',
'output = case variable',
"when 'value1'",
" 'output1'",
'else',
" 'output2'",
'end']
end
let(:correct_source) do
['output = case variable',
" when 'value1'",
" 'output1'",
' else',
" 'output2'",
' end',
'output = case variable',
" when 'value1'",
" 'output1'",
'else',
" 'output2'",
'end']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Indent `when` as deep as `case`.'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'does auto-correction' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq(correct_source.join("\n"))
end
end
end
context "a when clause that's deeper than case" do
let(:source) do
['case a',
' when 0 then return',
' else',
' case b',
' when 1 then return',
' end',
'end']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Indent `when` as deep as `case`.'] * 2)
end
it 'does auto-correction' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq(['case a',
'when 0 then return',
' else',
' case b',
' when 1 then return',
' end',
'end'].join("\n"))
end
end
it "accepts a when clause that's equally indented with case" do
source = ['y = case a',
' when 0 then break',
' when 0 then return',
' else',
' z = case b',
' when 1 then return',
' when 1 then break',
' end',
' end',
'case c',
'when 2 then encoding',
'end',
'']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it "doesn't get confused by strings with case in them" do
source = ['a = "case"',
'case x',
'when 0',
'end',
'']
inspect_source(cop, source)
expect(cop.messages).to be_empty
end
it "doesn't get confused by symbols named case or when" do
source = ['KEYWORDS = { :case => true, :when => true }',
'case type',
'when 0',
' ParameterNode',
'when 1',
' MethodCallNode',
'end',
'']
inspect_source(cop, source)
expect(cop.messages).to be_empty
end
it 'accepts correctly indented whens in complex combinations' do
source = ['each {',
' case state',
' when 0',
' case name',
' when :a',
' end',
' when 1',
' loop {',
' case name',
' when :b',
' end',
' }',
' end',
'}',
'case s',
'when Array',
'end',
'']
inspect_source(cop, source)
expect(cop.messages).to be_empty
end
end
context 'with IndentOneStep: true' do
let(:cop_config) do
{ 'EnforcedStyle' => 'case', 'IndentOneStep' => true }
end
context 'with everything on a single line' do
let(:source) { 'case foo; when :bar then 1; else 0; end' }
it 'does not register an offense' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
let(:correct_source) do
['output = case variable',
" when 'value1'",
" 'output1'",
' else',
" 'output2'",
' end']
end
context 'regarding assignment where the right hand side is a case' do
it 'accepts a correctly indented assignment' do
inspect_source(cop, correct_source)
expect(cop.offenses).to be_empty
end
context 'an assignment indented some other way' do
let(:source) do
['output = case variable',
" when 'value1'",
" 'output1'",
' else',
" 'output2'",
' end']
end
let(:correct_source) do
['output = case variable',
" when 'value1'",
" 'output1'",
' else',
" 'output2'",
' end']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages)
.to eq(['Indent `when` one step more than `case`.'])
end
it 'does auto-correction' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq correct_source.join("\n")
end
end
end
it "accepts a when clause that's 2 spaces deeper than case" do
source = ['case a',
' when 0 then return',
' else',
' case b',
' when 1 then return',
' end',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
context "a when clause that's equally indented with case" do
let(:source) do
['y = case a',
' when 0 then break',
' when 0 then return',
' z = case b',
' when 1 then return',
' when 1 then break',
' end',
' end',
'case c',
'when 2 then encoding',
'end',
'']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages)
.to eq(['Indent `when` one step more than `case`.'] * 5)
end
it 'does auto-correction' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq(['y = case a',
' when 0 then break',
' when 0 then return',
' z = case b',
' when 1 then return',
' when 1 then break',
' end',
' end',
'case c',
' when 2 then encoding',
'end',
''].join("\n"))
end
end
context 'when indentation width is overridden for this cop only' do
let(:cop_config) do
{
'EnforcedStyle' => 'case',
'IndentOneStep' => true,
'IndentationWidth' => 5
}
end
let(:source) do
['output = case variable',
" when 'value1'",
" 'output1'",
' else',
" 'output2'",
' end']
end
it 'respects cop-specific IndentationWidth' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
end
context 'with EnforcedStyle: end' do
context 'with IndentOneStep: false' do
let(:cop_config) do
{ 'EnforcedStyle' => 'end', 'IndentOneStep' => false }
end
context 'with everything on a single line' do
let(:source) { 'case foo; when :bar then 1; else 0; end' }
it 'does not register an offense' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
let(:correct_source) do
['output = case variable',
"when 'value1'",
" 'output1'",
'else',
" 'output2'",
'end']
end
context 'regarding assignment where the right hand side is a case' do
it 'accepts a correctly indented assignment' do
inspect_source(cop, correct_source)
expect(cop.offenses).to be_empty
end
context 'an assignment indented some other way' do
let(:source) do
['output = case variable',
" when 'value1'",
" 'output1'",
' else',
" 'output2'",
'end']
end
let(:correct_source) do
['output = case variable',
"when 'value1'",
" 'output1'",
' else',
" 'output2'",
'end']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Indent `when` as deep as `end`.'])
end
it 'does auto-correction' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq correct_source.join("\n")
end
end
end
end
context 'with IndentOneStep: true' do
let(:cop_config) do
{ 'EnforcedStyle' => 'end', 'IndentOneStep' => true }
end
context 'with everything on a single line' do
let(:source) { 'case foo; when :bar then 1; else 0; end' }
it 'does not register an offense' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
let(:correct_source) do
['output = case variable',
" when 'value1'",
" 'output1'",
' else',
" 'output2'",
'end']
end
context 'regarding assignment where the right hand side is a case' do
it 'accepts a correctly indented assignment' do
inspect_source(cop, correct_source)
expect(cop.offenses).to be_empty
end
context 'an assignment indented as case' do
let(:source) do
['output = case variable',
" when 'value1'",
" 'output1'",
' else',
" 'output2'",
' end']
end
let(:correct_source) do
['output = case variable',
" when 'value1'",
" 'output1'",
' else',
" 'output2'",
' end']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages)
.to eq(['Indent `when` one step more than `end`.'])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' =>
'case')
end
it 'does auto-correction' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq correct_source.join("\n")
end
end
context 'an assignment indented some other way' do
let(:source) do
['output = case variable',
" when 'value1'",
" 'output1'",
' else',
" 'output2'",
' end']
end
let(:correct_source) do
['output = case variable',
" when 'value1'",
" 'output1'",
' else',
" 'output2'",
' end']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages)
.to eq(['Indent `when` one step more than `end`.'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'does auto-correction' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq correct_source.join("\n")
end
end
end
end
end
context 'when case is preceded by something else than whitespace' do
let(:cop_config) { {} }
let(:source) do
['case test when something',
'end']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it "doesn't auto-correct" do
expect(autocorrect_source(cop, source))
.to eq(source.join("\n"))
expect(cop.offenses.map(&:corrected?)).to eq [false]
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/character_literal_spec.rb 0000664 0000000 0000000 00000002016 13070542236 0026467 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::CharacterLiteral do
subject(:cop) { described_class.new }
it 'registers an offense for character literals' do
inspect_source(cop, 'x = ?x')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for literals like \n' do
inspect_source(cop, 'x = ?\n')
expect(cop.offenses.size).to eq(1)
end
it 'accepts literals like ?\C-\M-d' do
inspect_source(cop, 'x = ?\C-\M-d')
expect(cop.offenses).to be_empty
end
it 'accepts ? in a %w literal' do
inspect_source(cop, '%w{? A}')
expect(cop.offenses).to be_empty
end
it "auto-corrects ?x to 'x'" do
new_source = autocorrect_source(cop, 'x = ?x')
expect(new_source).to eq("x = 'x'")
end
it 'auto-corrects ?\n to "\\n"' do
new_source = autocorrect_source(cop, 'x = ?\n')
expect(new_source).to eq('x = "\\n"')
end
it 'auto-corrects ?\' to "\'"' do
new_source = autocorrect_source(cop, 'x = ?\'')
expect(new_source).to eq('x = "\'"')
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/class_and_module_camel_case_spec.rb 0000664 0000000 0000000 00000001703 13070542236 0030451 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::ClassAndModuleCamelCase do
subject(:cop) { described_class.new }
it 'registers an offense for underscore in class and module name' do
inspect_source(cop,
['class My_Class',
'end',
'',
'module My_Module',
'end'])
expect(cop.offenses.size).to eq(2)
end
it 'is not fooled by qualified names' do
inspect_source(cop,
['class Top::My_Class',
'end',
'',
'module My_Module::Ala',
'end'])
expect(cop.offenses.size).to eq(2)
end
it 'accepts CamelCase names' do
inspect_source(cop,
['class MyClass',
'end',
'',
'module Mine',
'end'])
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/class_and_module_children_spec.rb 0000664 0000000 0000000 00000011100 13070542236 0030155 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::ClassAndModuleChildren, :config do
subject(:cop) { described_class.new(config) }
context 'nested style' do
let(:cop_config) { { 'EnforcedStyle' => 'nested' } }
it 'registers an offense for not nested classes' do
inspect_source(cop, ['class FooClass::BarClass',
'end'])
expect(cop.offenses.size).to eq 1
expect(cop.messages).to eq [
'Use nested module/class definitions instead of compact style.'
]
expect(cop.highlights).to eq ['FooClass::BarClass']
end
it 'registers an offense for not nested classes with explicit superclass' do
inspect_source(cop, ['class FooClass::BarClass < Super',
'end'])
expect(cop.offenses.size).to eq 1
expect(cop.messages).to eq [
'Use nested module/class definitions instead of compact style.'
]
expect(cop.highlights).to eq ['FooClass::BarClass']
end
it 'registers an offense for not nested modules' do
inspect_source(cop, ['module FooModule::BarModule',
'end'])
expect(cop.offenses.size).to eq 1
expect(cop.messages).to eq [
'Use nested module/class definitions instead of compact style.'
]
expect(cop.highlights).to eq ['FooModule::BarModule']
end
it 'accepts nested children' do
inspect_source(cop,
['class FooClass',
' class BarClass',
' end',
'end',
'',
'module FooModule',
' module BarModule',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts :: in parent class on inheritance' do
inspect_source(cop,
['class FooClass',
' class BarClass',
' end',
'end',
'',
'class BazClass < FooClass::BarClass',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'compact style' do
let(:cop_config) { { 'EnforcedStyle' => 'compact' } }
it 'registers a offense for classes with nested children' do
inspect_source(cop,
['class FooClass',
' class BarClass',
' end',
'end'])
expect(cop.offenses.size).to eq 1
expect(cop.messages).to eq [
'Use compact module/class definition instead of nested style.'
]
expect(cop.highlights).to eq ['FooClass']
end
it 'registers a offense for modules with nested children' do
inspect_source(cop,
['module FooModule',
' module BarModule',
' end',
'end'])
expect(cop.offenses.size).to eq 1
expect(cop.messages).to eq [
'Use compact module/class definition instead of nested style.'
]
expect(cop.highlights).to eq ['FooModule']
end
it 'accepts compact style for classes/modules' do
inspect_source(cop,
['class FooClass::BarClass',
'end',
'',
'module FooClass::BarModule',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts nesting for classes/modules with more than one child' do
inspect_source(cop,
['class FooClass',
' class BarClass',
' end',
' class BazClass',
' end',
'end',
'',
'module FooModule',
' module BarModule',
' end',
' class BazModule',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts class/module with single method' do
inspect_source(cop,
['class FooClass',
' def bar_method',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts nesting for classes with an explicit superclass' do
inspect_source(cop,
['class FooClass < Super',
' class BarClass',
' end',
'end'])
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/class_check_spec.rb 0000664 0000000 0000000 00000002301 13070542236 0025256 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::ClassCheck, :config do
subject(:cop) { described_class.new(config) }
context 'when enforced style is is_a?' do
let(:cop_config) { { 'EnforcedStyle' => 'is_a?' } }
it 'registers an offense for kind_of?' do
inspect_source(cop, 'x.kind_of? y')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['kind_of?'])
expect(cop.messages)
.to eq(['Prefer `Object#is_a?` over `Object#kind_of?`.'])
end
it 'auto-corrects kind_of? to is_a?' do
corrected = autocorrect_source(cop, ['x.kind_of? y'])
expect(corrected).to eq 'x.is_a? y'
end
end
context 'when enforced style is kind_of?' do
let(:cop_config) { { 'EnforcedStyle' => 'kind_of?' } }
it 'registers an offense for is_a?' do
inspect_source(cop, 'x.is_a? y')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['is_a?'])
expect(cop.messages)
.to eq(['Prefer `Object#kind_of?` over `Object#is_a?`.'])
end
it 'auto-corrects is_a? to kind_of?' do
corrected = autocorrect_source(cop, ['x.is_a? y'])
expect(corrected).to eq 'x.kind_of? y'
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/class_methods_spec.rb 0000664 0000000 0000000 00000004576 13070542236 0025664 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::ClassMethods do
subject(:cop) { described_class.new }
it 'registers an offense for methods using a class name' do
inspect_source(cop,
['class Test',
' def Test.some_method',
' do_something',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `self.some_method` instead of `Test.some_method`.'])
expect(cop.highlights).to eq(['Test'])
end
it 'registers an offense for methods using a module name' do
inspect_source(cop,
['module Test',
' def Test.some_method',
' do_something',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `self.some_method` instead of `Test.some_method`.'])
expect(cop.highlights).to eq(['Test'])
end
it 'does not register an offense for methods using self' do
inspect_source(cop,
['module Test',
' def self.some_method',
' do_something',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense for other top-level singleton methods' do
inspect_source(cop,
['class Test',
' X = Something.new',
'',
' def X.some_method',
' do_something',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense outside class/module bodies' do
inspect_source(cop,
['def Test.some_method',
' do_something',
'end'])
expect(cop.offenses).to be_empty
end
it 'autocorrects class name to self' do
src = ['class Test',
' def Test.some_method',
' do_something',
' end',
'end']
correct_source = ['class Test',
' def self.some_method',
' do_something',
' end',
'end'].join("\n")
new_source = autocorrect_source(cop, src)
expect(new_source).to eq(correct_source)
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/class_vars_spec.rb 0000664 0000000 0000000 00000001025 13070542236 0025156 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::ClassVars do
subject(:cop) { described_class.new }
it 'registers an offense for class variable declaration' do
inspect_source(cop, 'class TestClass; @@test = 10; end')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Replace class var @@test with a class instance var.'])
end
it 'does not register an offense for class variable usage' do
inspect_source(cop, '@@test.test(20)')
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/closing_parenthesis_indentation_spec.rb 0000664 0000000 0000000 00000017761 13070542236 0031473 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::ClosingParenthesisIndentation do
subject(:cop) { described_class.new(config) }
let(:config) do
RuboCop::Config.new('Style/AlignParameters' => {
'EnforcedStyle' => align_parameters_config
})
end
let(:align_parameters_config) { 'with_first_parameter' }
context 'for method calls' do
context 'with line break before 1st parameter' do
it 'registers an offense for misaligned )' do
inspect_source(cop, ['some_method(',
' a',
' )'])
expect(cop.messages)
.to eq(['Indent `)` the same as the start of the line where `(` is.'])
expect(cop.highlights).to eq([')'])
end
it 'autocorrects misaligned )' do
corrected = autocorrect_source(cop, ['some_method(',
' a',
' )'])
expect(corrected).to eq ['some_method(',
' a',
')'].join("\n")
end
it 'accepts a correctly aligned )' do
inspect_source(cop, ['some_method(',
' a',
')'])
expect(cop.offenses).to be_empty
end
end
context 'with no line break before 1st parameter' do
it 'registers an offense for misaligned )' do
inspect_source(cop, ['some_method(a',
')'])
expect(cop.messages).to eq(['Align `)` with `(`.'])
expect(cop.highlights).to eq([')'])
end
it 'autocorrects misaligned )' do
corrected = autocorrect_source(cop, ['some_method(a',
')'])
expect(corrected).to eq ['some_method(a',
' )'].join("\n")
end
it 'accepts a correctly aligned )' do
inspect_source(cop, ['some_method(a',
' )'])
expect(cop.offenses).to be_empty
end
it 'accepts empty ()' do
inspect_source(cop, 'some_method()')
expect(cop.offenses).to be_empty
end
context 'with fixed indentation of parameters' do
let(:align_parameters_config) { 'with_fixed_indentation' }
it 'accepts a correctly indented )' do
inspect_source(cop, ['some_method(a,',
' x: 1,',
' y: 2',
')',
'b =',
' some_method(a,',
' )'])
expect(cop.offenses).to be_empty
end
it 'autocorrects misindented )' do
corrected = autocorrect_source(cop, ['some_method(a,',
' x: 1,',
' y: 2',
' )',
'b =',
' some_method(a,',
' )'])
expect(corrected).to eq ['some_method(a,',
' x: 1,',
' y: 2',
')',
'b =',
' some_method(a,',
' )'].join("\n")
end
end
end
end
context 'for method definitions' do
context 'with line break before 1st parameter' do
it 'registers an offense for misaligned )' do
inspect_source(cop, ['def some_method(',
' a',
' )',
'end'])
expect(cop.messages)
.to eq(['Indent `)` the same as the start of the line where `(` is.'])
expect(cop.highlights).to eq([')'])
end
it 'autocorrects misaligned )' do
corrected = autocorrect_source(cop, ['def some_method(',
' a',
' )',
'end'])
expect(corrected).to eq ['def some_method(',
' a',
')',
'end'].join("\n")
end
it 'accepts a correctly aligned )' do
inspect_source(cop, ['def some_method(',
' a',
')',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with no line break before 1st parameter' do
it 'registers an offense for misaligned )' do
inspect_source(cop, ['def some_method(a',
')',
'end'])
expect(cop.messages).to eq(['Align `)` with `(`.'])
expect(cop.highlights).to eq([')'])
end
it 'autocorrects misaligned )' do
corrected = autocorrect_source(cop, ['def some_method(a',
')',
'end'])
expect(corrected).to eq ['def some_method(a',
' )',
'end'].join("\n")
end
it 'accepts a correctly aligned )' do
inspect_source(cop, ['def some_method(a',
' )',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts empty ()' do
inspect_source(cop, ['def some_method()',
'end'])
expect(cop.offenses).to be_empty
end
end
end
context 'for grouped expressions' do
context 'with line break before 1st operand' do
it 'registers an offense for misaligned )' do
inspect_source(cop, ['w = x * (',
' y + z',
' )'])
expect(cop.messages)
.to eq(['Indent `)` the same as the start of the line where `(` is.'])
expect(cop.highlights).to eq([')'])
end
it 'autocorrects misaligned )' do
corrected = autocorrect_source(cop, ['w = x * (',
' y + z',
' )'])
expect(corrected).to eq ['w = x * (',
' y + z',
')'].join("\n")
end
it 'accepts a correctly aligned )' do
inspect_source(cop, ['w = x * (',
' y + z',
')'])
expect(cop.offenses).to be_empty
end
end
context 'with no line break before 1st operand' do
it 'registers an offense for misaligned )' do
inspect_source(cop, ['w = x * (y + z',
')'])
expect(cop.messages).to eq(['Align `)` with `(`.'])
expect(cop.highlights).to eq([')'])
end
it 'autocorrects misaligned )' do
corrected = autocorrect_source(cop, ['w = x * (y + z',
' )'])
expect(corrected).to eq ['w = x * (y + z',
' )'].join("\n")
end
it 'accepts a correctly aligned )' do
inspect_source(cop, ['w = x * (y + z',
' )'])
expect(cop.offenses).to be_empty
end
it 'accepts ) that does not begin its line' do
inspect_source(cop, ['w = x * (y + z +',
' a)'])
expect(cop.offenses).to be_empty
end
end
end
it 'accepts begin nodes that are not grouped expressions' do
inspect_source(cop, ['def a',
' x',
' y',
'end'])
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/collection_methods_spec.rb 0000664 0000000 0000000 00000002622 13070542236 0026700 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::CollectionMethods, :config do
cop_config = {
'PreferredMethods' => {
'collect' => 'map',
'inject' => 'reduce',
'detect' => 'find',
'find_all' => 'select'
}
}
subject(:cop) { described_class.new(config) }
let(:cop_config) { cop_config }
cop_config['PreferredMethods'].each do |method, preferred_method|
it "registers an offense for #{method} with block" do
inspect_source(cop, "[1, 2, 3].#{method} { |e| e + 1 }")
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(["Prefer `#{preferred_method}` over `#{method}`."])
end
it "registers an offense for #{method} with proc param" do
inspect_source(cop, "[1, 2, 3].#{method}(&:test)")
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(["Prefer `#{preferred_method}` over `#{method}`."])
end
it "accepts #{method} with more than 1 param" do
inspect_source(cop, "[1, 2, 3].#{method}(other, &:test)")
expect(cop.offenses).to be_empty
end
it "accepts #{method} without a block" do
inspect_source(cop, "[1, 2, 3].#{method}")
expect(cop.offenses).to be_empty
end
it 'auto-corrects to preferred method' do
new_source = autocorrect_source(cop, 'some.collect(&:test)')
expect(new_source).to eq('some.map(&:test)')
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/colon_method_call_spec.rb 0000664 0000000 0000000 00000003144 13070542236 0026467 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::ColonMethodCall do
subject(:cop) { described_class.new }
it 'registers an offense for instance method call' do
inspect_source(cop, 'test::method_name')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for instance method call with arg' do
inspect_source(cop, 'test::method_name(arg)')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for class method call' do
inspect_source(cop, 'Class::method_name')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for class method call with arg' do
inspect_source(cop, 'Class::method_name(arg, arg2)')
expect(cop.offenses.size).to eq(1)
end
it 'does not register an offense for constant access' do
inspect_source(cop, 'Tip::Top::SOME_CONST')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for nested class' do
inspect_source(cop, 'Tip::Top.some_method')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for op methods' do
inspect_source(cop, 'Tip::Top.some_method[3]')
expect(cop.offenses).to be_empty
end
it 'does not register an offense when for constructor methods' do
inspect_source(cop, 'Tip::Top(some_arg)')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for Java static types' do
inspect_source(cop, 'Java::int')
expect(cop.offenses).to be_empty
end
it 'auto-corrects "::" with "."' do
new_source = autocorrect_source(cop, 'test::method')
expect(new_source).to eq('test.method')
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/command_literal_spec.rb 0000664 0000000 0000000 00000030246 13070542236 0026157 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::CommandLiteral, :config do
subject(:cop) { described_class.new(config) }
let(:config) do
supported_styles = {
'SupportedStyles' => %w[backticks percent_x mixed]
}
RuboCop::Config.new('Style/PercentLiteralDelimiters' =>
percent_literal_delimiters_config,
'Style/CommandLiteral' =>
cop_config.merge(supported_styles))
end
let(:percent_literal_delimiters_config) do
{ 'PreferredDelimiters' => { '%x' => '()' } }
end
describe '%x commands with other delimiters than parentheses' do
let(:cop_config) { { 'EnforcedStyle' => 'backticks' } }
it 'registers an offense' do
inspect_source(cop, '%x$ls$')
expect(cop.messages).to eq(['Use backticks around command string.'])
end
end
describe 'when PercentLiteralDelimiters is configured with curly braces' do
let(:cop_config) { { 'EnforcedStyle' => 'percent_x' } }
let(:percent_literal_delimiters_config) do
{ 'PreferredDelimiters' => { '%x' => '[]' } }
end
it 'respects the configuration when auto-correcting' do
new_source = autocorrect_source(cop, '`ls`')
expect(new_source).to eq('%x[ls]')
end
end
describe 'heredoc commands' do
let(:cop_config) { { 'EnforcedStyle' => 'backticks' } }
it 'is ignored' do
inspect_source(cop, ['<<`COMMAND`',
' ls',
'COMMAND'])
expect(cop.offenses).to be_empty
end
end
context 'when EnforcedStyle is set to backticks' do
let(:cop_config) { { 'EnforcedStyle' => 'backticks' } }
describe 'a single-line ` string without backticks' do
let(:source) { 'foo = `ls`' }
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
describe 'a single-line ` string with backticks' do
let(:source) { 'foo = `echo \`ls\``' }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `%x` around command string.'])
end
it 'cannot auto-correct' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
describe 'when configured to allow inner backticks' do
before { cop_config['AllowInnerBackticks'] = true }
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
describe 'a multi-line ` string without backticks' do
let(:source) do
['foo = `',
' ls',
' ls -l',
'`']
end
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
describe 'a multi-line ` string with backticks' do
let(:source) do
['foo = `',
' echo \`ls\`',
' echo \`ls -l\`',
'`']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `%x` around command string.'])
end
it 'cannot auto-correct' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source.join("\n"))
end
describe 'when configured to allow inner backticks' do
before { cop_config['AllowInnerBackticks'] = true }
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
describe 'a single-line %x string without backticks' do
let(:source) { 'foo = %x(ls)' }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use backticks around command string.'])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('foo = `ls`')
end
end
describe 'a single-line %x string with backticks' do
let(:source) { 'foo = %x(echo `ls`)' }
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
describe 'when configured to allow inner backticks' do
before { cop_config['AllowInnerBackticks'] = true }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use backticks around command string.'])
end
it 'cannot auto-correct' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
end
end
describe 'a multi-line %x string without backticks' do
let(:source) do
['foo = %x(',
' ls',
' ls -l',
')']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use backticks around command string.'])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("foo = `\n ls\n ls -l\n`")
end
end
describe 'a multi-line %x string with backticks' do
let(:source) do
['foo = %x(',
' echo `ls`',
' echo `ls -l`',
')']
end
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
describe 'when configured to allow inner backticks' do
before { cop_config['AllowInnerBackticks'] = true }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use backticks around command string.'])
end
it 'cannot auto-correct' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source.join("\n"))
end
end
end
end
context 'when EnforcedStyle is set to percent_x' do
let(:cop_config) { { 'EnforcedStyle' => 'percent_x' } }
describe 'a single-line ` string without backticks' do
let(:source) { 'foo = `ls`' }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `%x` around command string.'])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('foo = %x(ls)')
end
end
describe 'a single-line ` string with backticks' do
let(:source) { 'foo = `echo \`ls\``' }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `%x` around command string.'])
end
it 'cannot auto-correct' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
end
describe 'a multi-line ` string without backticks' do
let(:source) do
['foo = `',
' ls',
' ls -l',
'`']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `%x` around command string.'])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("foo = %x(\n ls\n ls -l\n)")
end
end
describe 'a multi-line ` string with backticks' do
let(:source) do
['foo = `',
' echo \`ls\`',
' echo \`ls -l\`',
'`']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `%x` around command string.'])
end
it 'cannot auto-correct' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source.join("\n"))
end
end
describe 'a single-line %x string without backticks' do
let(:source) { 'foo = %x(ls)' }
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
describe 'a single-line %x string with backticks' do
let(:source) { 'foo = %x(echo `ls`)' }
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
describe 'a multi-line %x string without backticks' do
let(:source) do
['foo = %x(',
' ls',
' ls -l',
')']
end
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
describe 'a multi-line %x string with backticks' do
let(:source) do
['foo = %x(',
' echo `ls`',
' echo `ls -l`',
')']
end
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
context 'when EnforcedStyle is set to mixed' do
let(:cop_config) { { 'EnforcedStyle' => 'mixed' } }
describe 'a single-line ` string without backticks' do
let(:source) { 'foo = `ls`' }
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
describe 'a single-line ` string with backticks' do
let(:source) { 'foo = `echo \`ls\``' }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `%x` around command string.'])
end
it 'cannot auto-correct' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
describe 'when configured to allow inner backticks' do
before { cop_config['AllowInnerBackticks'] = true }
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
describe 'a multi-line ` string without backticks' do
let(:source) do
['foo = `',
' ls',
' ls -l',
'`']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `%x` around command string.'])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("foo = %x(\n ls\n ls -l\n)")
end
end
describe 'a multi-line ` string with backticks' do
let(:source) do
['foo = `',
' echo \`ls\`',
' echo \`ls -l\`',
'`']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `%x` around command string.'])
end
it 'cannot auto-correct' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source.join("\n"))
end
end
describe 'a single-line %x string without backticks' do
let(:source) { 'foo = %x(ls)' }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use backticks around command string.'])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('foo = `ls`')
end
end
describe 'a single-line %x string with backticks' do
let(:source) { 'foo = %x(echo `ls`)' }
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
describe 'when configured to allow inner backticks' do
before { cop_config['AllowInnerBackticks'] = true }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use backticks around command string.'])
end
it 'cannot auto-correct' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
end
end
describe 'a multi-line %x string without backticks' do
let(:source) do
['foo = %x(',
' ls',
' ls -l',
')']
end
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
describe 'a multi-line %x string with backticks' do
let(:source) do
['foo = %x(',
' echo `ls`',
' echo `ls -l`',
')']
end
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/comment_annotation_spec.rb 0000664 0000000 0000000 00000010160 13070542236 0026712 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::CommentAnnotation, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) do
{ 'Keywords' => %w[TODO FIXME OPTIMIZE HACK REVIEW] }
end
context 'missing colon' do
it 'registers an offense' do
inspect_source(cop, '# TODO make better')
expect(cop.messages).to eq([format(described_class::MSG, 'TODO')])
expect(cop.highlights).to eq(['TODO '])
end
it 'autocorrects' do
corrected = autocorrect_source(cop, '# TODO make better')
expect(corrected).to eq('# TODO: make better')
end
end
context 'with configured keyword' do
let(:cop_config) { { 'Keywords' => %w[ISSUE] } }
it 'registers an offense for a missing colon after the word' do
inspect_source(cop, '# ISSUE wrong order')
expect(cop.messages).to eq([format(described_class::MSG, 'ISSUE')])
expect(cop.highlights).to eq(['ISSUE '])
end
it 'autocorrects a missing colon after keyword' do
corrected = autocorrect_source(cop, '# ISSUE wrong order')
expect(corrected).to eq('# ISSUE: wrong order')
end
end
context 'missing space after colon' do
it 'registers an offense' do
inspect_source(cop, '# TODO:make better')
expect(cop.messages).to eq([format(described_class::MSG, 'TODO')])
expect(cop.highlights).to eq(['TODO:'])
end
it 'autocorrects' do
corrected = autocorrect_source(cop, '# TODO:make better')
expect(corrected).to eq('# TODO: make better')
end
end
context 'lower case keyword' do
it 'registers an offense' do
inspect_source(cop, '# fixme: does not work')
expect(cop.messages).to eq([format(described_class::MSG, 'fixme')])
expect(cop.highlights).to eq(['fixme: '])
end
it 'autocorrects' do
corrected = autocorrect_source(cop, '# fixme: does not work')
expect(corrected).to eq('# FIXME: does not work')
end
end
context 'capitalized keyword' do
it 'registers an offense' do
inspect_source(cop, '# Optimize: does not work')
expect(cop.messages).to eq([format(described_class::MSG, 'Optimize')])
expect(cop.highlights).to eq(['Optimize: '])
end
it 'autocorrects' do
corrected = autocorrect_source(cop, '# Optimize: does not work')
expect(corrected).to eq('# OPTIMIZE: does not work')
end
end
context 'upper case keyword with colon by no note' do
it 'registers an offense' do
inspect_source(cop, '# HACK:')
expect(cop.messages)
.to eq(['Annotation comment, with keyword `HACK`, is missing a note.'])
expect(cop.highlights).to eq(['HACK:'])
end
it 'does not autocorrects' do
source = '# HACK:'
corrected = autocorrect_source(cop, source)
expect(corrected).to eq(source)
end
end
it 'accepts upper case keyword with colon, space and note' do
inspect_source(cop, '# REVIEW: not sure about this')
expect(cop.offenses).to be_empty
end
it 'accepts upper case keyword alone' do
inspect_source(cop, '# OPTIMIZE')
expect(cop.offenses).to be_empty
end
it 'accepts a comment that is obviously a code example' do
inspect_source(cop, '# Todo.destroy(1)')
expect(cop.offenses).to be_empty
end
it 'accepts a keyword that is just the beginning of a sentence' do
inspect_source(cop,
["# Optimize if you want. I wouldn't recommend it.",
'# Hack is a fun game.'])
expect(cop.offenses).to be_empty
end
it 'accepts a keyword that is somewhere in a sentence' do
src = ['# Example: There are three reviews, with ranks 1, 2, and 3. A new',
'# review is saved with rank 2. The two reviews that originally had',
'# ranks 2 and 3 will have their ranks increased to 3 and 4.']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
context 'when a keyword is not in the configuration' do
let(:cop_config) do
{ 'Keywords' => %w[FIXME OPTIMIZE HACK REVIEW] }
end
it 'accepts the word without colon' do
inspect_source(cop, '# TODO make better')
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/comment_indentation_spec.rb 0000664 0000000 0000000 00000015507 13070542236 0027066 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::CommentIndentation do
subject(:cop) { described_class.new(config) }
let(:config) do
RuboCop::Config
.new('Style/IndentationWidth' => { 'Width' => indentation_width })
end
let(:indentation_width) { 2 }
context 'on outer level' do
it 'accepts a correctly indented comment' do
inspect_source(cop, '# comment')
expect(cop.offenses).to be_empty
end
it 'accepts a comment that follows code' do
inspect_source(cop, 'hello # comment')
expect(cop.offenses).to be_empty
end
it 'accepts a documentation comment' do
inspect_source(cop, ['=begin',
'Doc comment',
'=end',
' hello',
' #',
'hi'])
expect(cop.highlights).to eq(['#'])
end
it 'registers an offense for an incorrectly indented (1) comment' do
inspect_source(cop, ' # comment')
expect(cop.messages)
.to eq(['Incorrect indentation detected (column 1 instead of 0).'])
expect(cop.highlights).to eq(['# comment'])
end
it 'registers an offense for an incorrectly indented (2) comment' do
inspect_source(cop, ' # comment')
expect(cop.messages)
.to eq(['Incorrect indentation detected (column 2 instead of 0).'])
end
it 'registers an offense for each incorrectly indented comment' do
inspect_source(cop, ['# a',
' # b',
' # c',
'# d',
'def test; end'])
expect(cop.messages)
.to eq(['Incorrect indentation detected (column 0 instead of 2).',
'Incorrect indentation detected (column 2 instead of 4).',
'Incorrect indentation detected (column 4 instead of 0).'])
end
end
it 'registers offenses before __END__ but not after' do
inspect_source(cop, [' #',
'__END__',
' #'])
expect(cop.messages)
.to eq(['Incorrect indentation detected (column 1 instead of 0).'])
end
context 'around program structure keywords' do
it 'accepts correctly indented comments' do
inspect_source(cop, ['#',
'def m',
' #',
' if a',
' #',
' b',
' # this is accepted',
' elsif aa',
' # this is accepted',
' else',
' #',
' end',
' #',
' case a',
' # this is accepted',
' when 0',
' #',
' b',
' end',
' # this is accepted',
'rescue',
'# this is accepted',
'ensure',
' #',
'end',
'#'])
expect(cop.offenses).to eq([])
end
context 'with a blank line following the comment' do
it 'accepts a correctly indented comment' do
inspect_source(cop, ['def m',
' # comment',
'',
'end'])
expect(cop.offenses).to be_empty
end
end
end
context 'near various kinds of brackets' do
it 'accepts correctly indented comments' do
inspect_source(cop, ['#',
'a = {',
' #',
' x: [',
' 1',
' #',
' ],',
' #',
' y: func(',
' 1',
' #',
' )',
' #',
'}',
'#'])
expect(cop.offenses).to eq([])
end
it 'is unaffected by closing bracket that does not begin a line' do
inspect_source(cop, ['#',
'result = []'])
expect(cop.messages).to eq([])
end
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, [' # comment',
'hash1 = { a: 0,',
' # comment',
' bb: 1,',
' ccc: 2 }',
' if a',
' #',
' b',
' # this is accepted',
' elsif aa',
' # so is this',
' elsif bb',
'#',
' else',
' #',
' end',
' case a',
' # this is accepted',
' when 0',
' # so is this',
' when 1',
' #',
' b',
' end'])
expect(new_source).to eq(['# comment',
'hash1 = { a: 0,',
' # comment',
' bb: 1,',
' ccc: 2 }',
' if a',
' #',
' b',
' # this is accepted',
' elsif aa',
' # so is this',
' elsif bb',
' #',
' else',
' #',
' end',
' case a',
' # this is accepted',
' when 0',
' # so is this',
' when 1',
' #',
' b',
' end'].join("\n"))
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/conditional_assignment_assign_in_condition_spec.rb 0000664 0000000 0000000 00000113771 13070542236 0033665 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::ConditionalAssignment do
subject(:cop) { described_class.new(config) }
shared_examples 'all variable types' do |variable|
it 'registers an offense assigning any variable type to ternary' do
inspect_source(cop, "#{variable} = foo? ? 1 : 2")
expect(cop.messages).to eq([described_class::ASSIGN_TO_CONDITION_MSG])
end
it 'allows assigning any variable type inside ternary' do
inspect_source(cop, "foo? ? #{variable} = 1 : #{variable} = 2")
expect(cop.offenses).to be_empty
end
it 'registers an offense assigning any variable type to if else' do
source = ["#{variable} = if foo",
' 1',
' else',
' 2',
' end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::ASSIGN_TO_CONDITION_MSG])
end
it 'registers an offense assigning any variable type to if elsif else' do
source = ["#{variable} = if foo",
' 1',
' elsif baz',
' 2',
' else',
' 3',
' end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::ASSIGN_TO_CONDITION_MSG])
end
it 'registers an offense assigning any variable type to if else' \
'with multiple assignment' do
source = ["#{variable}, #{variable} = if foo",
' something',
' else',
' something_else',
' end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::ASSIGN_TO_CONDITION_MSG])
end
it 'allows assigning any variable type inside if else' \
'with multiple assignment' do
source = ['if foo',
" #{variable}, #{variable} = something",
'else',
" #{variable}, #{variable} = something_else",
'end']
inspect_source(cop, source)
expect(cop.messages).to be_empty
end
it 'allows assigning any variable type inside if else' do
source = ['if foo',
" #{variable} = 1",
'else',
" #{variable} = 2",
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows assignment to if without else' do
source = ["#{variable} = if foo",
' 1',
' end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'registers an offense assigning any variable type to unless else' do
source = ["#{variable} = unless foo",
' 1',
' else',
' 2',
' end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::ASSIGN_TO_CONDITION_MSG])
end
it 'allows assigning any variable type inside unless else' do
source = ['unless foo',
" #{variable} = 1",
'else',
" #{variable} = 2",
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'registers an offense for assigning any variable type to case when' do
source = ["#{variable} = case foo",
' when "a"',
' 1',
' else',
' 2',
' end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::ASSIGN_TO_CONDITION_MSG])
end
it 'allows assigning any variable type inside case when' do
source = ['case foo',
'when "a"',
" #{variable} = 1",
'else',
" #{variable} = 2",
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'does not crash for rescue assignment' do
source = ['begin',
' foo',
"rescue => #{variable}",
' bar',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
context 'auto-correct' do
it 'corrects assigning any variable type to ternary' do
new_source = autocorrect_source(cop, "#{variable} = foo? ? 1 : 2")
expect(new_source).to eq("foo? ? #{variable} = 1 : #{variable} = 2")
end
it 'corrects assigning any variable type to if elsif else' do
source = ["#{variable} = if foo",
' 1',
' elsif baz',
' 2',
' else',
' 3',
' end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['if foo',
" #{variable} = 1",
'elsif baz',
" #{variable} = 2",
'else',
" #{variable} = 3",
'end'].join("\n"))
end
it 'corrects assigning any variable type to unless else' do
source = ["#{variable} = unless foo",
' 1',
' else',
' 2',
' end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['unless foo',
" #{variable} = 1",
'else',
" #{variable} = 2",
'end'].join("\n"))
end
it 'corrects assigning any variable type to case when' do
source = ["#{variable} = case foo",
' when "a"',
' 1',
' when "b"',
' 2',
' else',
' 3',
' end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['case foo',
'when "a"',
" #{variable} = 1",
'when "b"',
" #{variable} = 2",
'else',
" #{variable} = 3",
'end'].join("\n"))
end
end
end
shared_examples 'all assignment types' do |assignment|
it 'registers an offense for any assignment to ternary' do
inspect_source(cop, "bar #{assignment} (foo? ? 1 : 2)")
expect(cop.messages).to eq([described_class::ASSIGN_TO_CONDITION_MSG])
end
it 'registers an offense any assignment to if else' do
source = ["bar #{assignment} if foo",
' 1',
' else',
' 2',
' end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::ASSIGN_TO_CONDITION_MSG])
end
it 'allows any assignment to if without else' do
source = ["bar #{assignment} if foo",
' 1',
' end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'registers an offense for any assignment to unless else' do
source = ["bar #{assignment} unless foo",
' 1',
' else',
' 2',
' end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::ASSIGN_TO_CONDITION_MSG])
end
it 'registers an offense any assignment to case when' do
source = ["bar #{assignment} case foo",
' when "a"',
' 1',
' else',
' 2',
' end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::ASSIGN_TO_CONDITION_MSG])
end
context 'auto-correct' do
it 'corrects any assignment to ternary' do
new_source = autocorrect_source(cop, "bar #{assignment} (foo? ? 1 : 2)")
expect(new_source)
.to eq("foo? ? bar #{assignment} 1 : bar #{assignment} 2")
end
it 'corrects any assignment to if else' do
source = ["bar #{assignment} if foo",
' 1',
' else',
' 2',
' end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['if foo',
" bar #{assignment} 1",
'else',
" bar #{assignment} 2",
'end'].join("\n"))
end
it 'corrects any assignment to unless else' do
source = ["bar #{assignment} unless foo",
' 1',
' else',
' 2',
' end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['unless foo',
" bar #{assignment} 1",
'else',
" bar #{assignment} 2",
'end'].join("\n"))
end
it 'corrects any assignment to case when' do
source = ["bar #{assignment} case foo",
' when "a"',
' 1',
' else',
' 2',
' end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['case foo',
'when "a"',
" bar #{assignment} 1",
'else',
" bar #{assignment} 2",
'end'].join("\n"))
end
end
end
shared_examples 'multiline all variable types' do |variable, expected|
it 'assigning any variable type to a multiline if else' do
source = ["#{variable} = if foo",
' something',
' 1',
' else',
' something_else',
' 2',
' end']
inspect_source(cop, source)
expect(cop.messages).to eq(expected)
end
it 'assigning any variable type to an if else with multiline ' \
'in one branch' do
source = ["#{variable} = if foo",
' 1',
' else',
' something_else',
' 2',
' end']
inspect_source(cop, source)
expect(cop.messages).to eq(expected)
end
it 'assigning any variable type to a multiline if elsif else' do
source = ["#{variable} = if foo",
' something',
' 1',
' elsif',
' something_other',
' 2',
' elsif',
' something_other_again',
' 3',
' else',
' something_else',
' 4',
' end']
inspect_source(cop, source)
expect(cop.messages).to eq(expected)
end
it 'assigning any variable type to a multiline unless else' do
source = ["#{variable} = unless foo",
' something',
' 1',
' else',
' something_else',
' 2',
' end']
inspect_source(cop, source)
expect(cop.messages).to eq(expected)
end
it 'assigning any variable type to a multiline case when' do
source = ["#{variable} = case foo",
' when "a"',
' something',
' 1',
' else',
' something_else',
' 2',
' end']
inspect_source(cop, source)
expect(cop.messages).to eq(expected)
end
end
shared_examples 'multiline all assignment types' do |assignment, expected|
it 'any assignment to a multiline if else' do
source = ["bar #{assignment} if foo",
' something',
' 1',
' else',
' something_else',
' 2',
' end']
inspect_source(cop, source)
expect(cop.messages).to eq(expected)
end
it 'any assignment to a multiline unless else' do
source = ["bar #{assignment} unless foo",
' something',
' 1',
' else',
' something_else',
' 2',
' end']
inspect_source(cop, source)
expect(cop.messages).to eq(expected)
end
it 'any assignment to a multiline case when' do
source = ["bar #{assignment} case foo",
' when "a"',
' something',
' 1',
' else',
' something_else',
' 2',
' end']
inspect_source(cop, source)
expect(cop.messages).to eq(expected)
end
end
shared_examples 'single line condition auto-correct' do
it 'corrects assignment to an if else condition' do
source = ['bar = if foo',
' 1',
' else',
' 2',
' end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['if foo',
' bar = 1',
'else',
' bar = 2',
'end'].join("\n"))
end
it 'corrects assignment to an if elsif else condition' do
source = ['bar = if foo',
' 1',
' elsif foobar',
' 2',
' else',
' 3',
' end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['if foo',
' bar = 1',
'elsif foobar',
' bar = 2',
'else',
' bar = 3',
'end'].join("\n"))
end
it 'corrects assignment to an if elsif else with multiple elsifs' do
source = ['bar = if foo',
' 1',
' elsif foobar',
' 2',
' elsif baz',
' 3',
' else',
' 4',
' end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['if foo',
' bar = 1',
'elsif foobar',
' bar = 2',
'elsif baz',
' bar = 3',
'else',
' bar = 4',
'end'].join("\n"))
end
it 'corrects assignment to an unless else condition' do
source = ['bar = unless foo',
' 1',
' else',
' 2',
' end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['unless foo',
' bar = 1',
'else',
' bar = 2',
'end'].join("\n"))
end
it 'corrects assignment to a case when else condition' do
source = ['bar = case foo',
' when foobar',
' 1',
' else',
' 2',
' end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['case foo',
'when foobar',
' bar = 1',
'else',
' bar = 2',
'end'].join("\n"))
end
it 'corrects assignment to a case when else with multiple whens' do
source = ['bar = case foo',
' when foobar',
' 1',
' when baz',
' 2',
' else',
' 3',
' end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['case foo',
'when foobar',
' bar = 1',
'when baz',
' bar = 2',
'else',
' bar = 3',
'end'].join("\n"))
end
it 'corrects assignment to a ternary operator' do
new_source = autocorrect_source(cop, 'bar = foo? ? 1 : 2')
expect(new_source).to eq('foo? ? bar = 1 : bar = 2')
end
end
context 'SingleLineConditionsOnly true' do
let(:config) do
RuboCop::Config.new('Style/ConditionalAssignment' => {
'Enabled' => true,
'SingleLineConditionsOnly' => true,
'IncludeTernaryExpressions' => true,
'EnforcedStyle' => 'assign_inside_condition',
'SupportedStyles' => %w[assign_to_condition
assign_inside_condition]
},
'Lint/EndAlignment' => {
'EnforcedStyleAlignWith' => 'keyword',
'Enabled' => true
},
'Metrics/LineLength' => {
'Max' => 80,
'Enabled' => true
})
end
it_behaves_like('all variable types', 'bar')
it_behaves_like('all variable types', 'BAR')
it_behaves_like('all variable types', 'FOO::BAR')
it_behaves_like('all variable types', '@bar')
it_behaves_like('all variable types', '@@bar')
it_behaves_like('all variable types', '$BAR')
it_behaves_like('all variable types', 'foo.bar')
it_behaves_like('multiline all variable types', 'bar', [])
it_behaves_like('multiline all variable types', 'BAR', [])
it_behaves_like('multiline all variable types', 'FOO::BAR', [])
it_behaves_like('multiline all variable types', '@bar', [])
it_behaves_like('multiline all variable types', '@@bar', [])
it_behaves_like('multiline all variable types', '$BAR', [])
it_behaves_like('multiline all variable types', 'foo.bar', [])
it_behaves_like('all assignment types', '=')
it_behaves_like('all assignment types', '==')
it_behaves_like('all assignment types', '===')
it_behaves_like('all assignment types', '+=')
it_behaves_like('all assignment types', '-=')
it_behaves_like('all assignment types', '*=')
it_behaves_like('all assignment types', '**=')
it_behaves_like('all assignment types', '/=')
it_behaves_like('all assignment types', '%=')
it_behaves_like('all assignment types', '^=')
it_behaves_like('all assignment types', '&=')
it_behaves_like('all assignment types', '|=')
it_behaves_like('all assignment types', '<=')
it_behaves_like('all assignment types', '>=')
it_behaves_like('all assignment types', '<<=')
it_behaves_like('all assignment types', '>>=')
it_behaves_like('all assignment types', '||=')
it_behaves_like('all assignment types', '&&=')
it_behaves_like('all assignment types', '+=')
it_behaves_like('all assignment types', '-=')
it_behaves_like('all assignment types', '<<')
it_behaves_like('multiline all assignment types', '=', [])
it_behaves_like('multiline all assignment types', '==', [])
it_behaves_like('multiline all assignment types', '===', [])
it_behaves_like('multiline all assignment types', '+=', [])
it_behaves_like('multiline all assignment types', '-=', [])
it_behaves_like('multiline all assignment types', '*=', [])
it_behaves_like('multiline all assignment types', '**=', [])
it_behaves_like('multiline all assignment types', '/=', [])
it_behaves_like('multiline all assignment types', '%=', [])
it_behaves_like('multiline all assignment types', '^=', [])
it_behaves_like('multiline all assignment types', '&=', [])
it_behaves_like('multiline all assignment types', '|=', [])
it_behaves_like('multiline all assignment types', '<=', [])
it_behaves_like('multiline all assignment types', '>=', [])
it_behaves_like('multiline all assignment types', '<<=', [])
it_behaves_like('multiline all assignment types', '>>=', [])
it_behaves_like('multiline all assignment types', '||=', [])
it_behaves_like('multiline all assignment types', '&&=', [])
it_behaves_like('multiline all assignment types', '+=', [])
it_behaves_like('multiline all assignment types', '-=', [])
it_behaves_like('multiline all assignment types', '<<', [])
it 'allows a method call in the subject of a ternary operator' do
inspect_source(cop, 'bar << foo? ? 1 : 2')
expect(cop.offenses).to be_empty
end
it 'registers an offense for assignment using a method that ends with ' \
'an equal sign' do
inspect_source(cop, 'self.attributes = foo? ? 1 : 2')
expect(cop.messages).to eq([described_class::ASSIGN_TO_CONDITION_MSG])
end
it 'registers an offense for assignment using []=' do
source = ['foo[:a] = if bar?',
' 1',
' else',
' 2',
' end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::ASSIGN_TO_CONDITION_MSG])
end
it 'registers an offense for assignment to an if then else' do
source = ['bar = if foo then 1',
' else 2',
' end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::ASSIGN_TO_CONDITION_MSG])
end
it 'registers an offense for assignment to case when then else' do
source = ['baz = case foo',
' when bar then 1',
' else 2',
' end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::ASSIGN_TO_CONDITION_MSG])
end
context 'auto-correct' do
it_behaves_like('single line condition auto-correct')
it 'corrects assignment to an if then else' do
source = ['bar = if foo then 1',
' else 2',
' end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['if foo then bar = 1',
'else bar = 2',
'end'].join("\n"))
end
it 'corrects assignment to case when then else' do
source = ['baz = case foo',
' when bar then 1',
' else 2',
' end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['case foo',
'when bar then baz = 1',
'else baz = 2',
'end'].join("\n"))
end
it 'corrects assignment using a method that ends with an equal sign' do
new_source = autocorrect_source(cop, 'self.attributes = foo? ? 1 : 2')
expect(new_source)
.to eq('foo? ? self.attributes = 1 : self.attributes = 2')
end
it 'corrects assignment using []=' do
source = ['foo[:a] = if bar?',
' 1',
' else',
' 2',
' end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['if bar?',
' foo[:a] = 1',
'else',
' foo[:a] = 2',
'end'].join("\n"))
end
it 'corrects assignment to a namespaced constant' do
source = ['FOO::BAR = if baz?',
' 1',
' else',
' 2',
' end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['if baz?',
' FOO::BAR = 1',
'else',
' FOO::BAR = 2',
'end'].join("\n"))
end
end
end
context 'SingleLineConditionsOnly false' do
let(:config) do
RuboCop::Config.new('Style/ConditionalAssignment' => {
'Enabled' => true,
'SingleLineConditionsOnly' => false,
'IncludeTernaryExpressions' => true,
'EnforcedStyle' => 'assign_inside_condition',
'SupportedStyles' => %w[assign_to_condition
assign_inside_condition]
},
'Lint/EndAlignment' => {
'EnforcedStyleAlignWith' => 'keyword',
'Enabled' => true
},
'Metrics/LineLength' => {
'Max' => 80,
'Enabled' => true
})
end
it_behaves_like('all variable types', 'bar')
it_behaves_like('all variable types', 'BAR')
it_behaves_like('all variable types', 'FOO::BAR')
it_behaves_like('all variable types', '@bar')
it_behaves_like('all variable types', '@@bar')
it_behaves_like('all variable types', '$BAR')
it_behaves_like('all variable types', 'foo.bar')
it_behaves_like('multiline all variable types', 'bar',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all variable types', 'BAR',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all variable types', 'FOO::BAR',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all variable types', '@bar',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all variable types', '@@bar',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all variable types', '$BAR',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all variable types', 'foo.bar',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('all assignment types', '=')
it_behaves_like('all assignment types', '==')
it_behaves_like('all assignment types', '===')
it_behaves_like('all assignment types', '+=')
it_behaves_like('all assignment types', '-=')
it_behaves_like('all assignment types', '*=')
it_behaves_like('all assignment types', '**=')
it_behaves_like('all assignment types', '/=')
it_behaves_like('all assignment types', '%=')
it_behaves_like('all assignment types', '^=')
it_behaves_like('all assignment types', '&=')
it_behaves_like('all assignment types', '|=')
it_behaves_like('all assignment types', '<=')
it_behaves_like('all assignment types', '>=')
it_behaves_like('all assignment types', '<<=')
it_behaves_like('all assignment types', '>>=')
it_behaves_like('all assignment types', '||=')
it_behaves_like('all assignment types', '&&=')
it_behaves_like('all assignment types', '+=')
it_behaves_like('all assignment types', '-=')
it_behaves_like('all assignment types', '<<')
it_behaves_like('multiline all assignment types', '=',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all assignment types', '==',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all assignment types', '===',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all assignment types', '+=',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all assignment types', '-=',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all assignment types', '*=',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all assignment types', '**=',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all assignment types', '/=',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all assignment types', '%=',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all assignment types', '^=',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all assignment types', '&=',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all assignment types', '|=',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all assignment types', '<=',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all assignment types', '>=',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all assignment types', '<<=',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all assignment types', '>>=',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all assignment types', '||=',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all assignment types', '&&=',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all assignment types', '+=',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all assignment types', '-=',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('multiline all assignment types', '<<',
[described_class::ASSIGN_TO_CONDITION_MSG])
it_behaves_like('single line condition auto-correct')
it 'corrects assignment to a multiline if else condition' do
source = ['bar = if foo',
' something',
' 1',
' else',
' something_else',
' 2',
' end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['if foo',
' something',
' bar = 1',
'else',
' something_else',
' bar = 2',
'end'].join("\n"))
end
it 'corrects assignment to a multiline if elsif else condition' do
source = ['bar = if foo',
' something',
' 1',
' elsif foobar',
' something_elsif',
' 2',
' else',
' something_else',
' 3',
' end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['if foo',
' something',
' bar = 1',
'elsif foobar',
' something_elsif',
' bar = 2',
'else',
' something_else',
' bar = 3',
'end'].join("\n"))
end
it 'corrects assignment to an if elsif else with multiple elsifs' do
source = ['bar = if foo',
' something',
' 1',
' elsif foobar',
' something_elsif1',
' 2',
' elsif baz',
' something_elsif2',
' 3',
' else',
' something_else',
' 4',
' end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['if foo',
' something',
' bar = 1',
'elsif foobar',
' something_elsif1',
' bar = 2',
'elsif baz',
' something_elsif2',
' bar = 3',
'else',
' something_else',
' bar = 4',
'end'].join("\n"))
end
it 'corrects assignment to an unless else condition' do
source = ['bar = unless foo',
' something',
' 1',
' else',
' something_else',
' 2',
' end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['unless foo',
' something',
' bar = 1',
'else',
' something_else',
' bar = 2',
'end'].join("\n"))
end
it 'corrects assignment to a case when else condition' do
source = ['bar = case foo',
' when foobar',
' something',
' 1',
' else',
' something_else',
' 2',
' end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['case foo',
'when foobar',
' something',
' bar = 1',
'else',
' something_else',
' bar = 2',
'end'].join("\n"))
end
it 'corrects assignment to a case when else with multiple whens' do
source = ['bar = case foo',
' when foobar',
' something',
' 1',
' when baz',
' something_other',
' 2',
' else',
' something_else',
' 3',
' end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['case foo',
'when foobar',
' something',
' bar = 1',
'when baz',
' something_other',
' bar = 2',
'else',
' something_else',
' bar = 3',
'end'].join("\n"))
end
end
context 'IncludeTernaryExpressions false' do
let(:config) do
RuboCop::Config.new('Style/ConditionalAssignment' => {
'Enabled' => true,
'SingleLineConditionsOnly' => true,
'IncludeTernaryExpressions' => false,
'EnforcedStyle' => 'assign_inside_condition',
'SupportedStyles' => %w[assign_to_condition
assign_inside_condition]
},
'Lint/EndAlignment' => {
'EnforcedStyleAlignWith' => 'keyword',
'Enabled' => true
},
'Metrics/LineLength' => {
'Max' => 80,
'Enabled' => true
})
end
it 'allows assigning any variable type to ternary' do
inspect_source(cop, 'bar = foo? ? 1 : 2')
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/conditional_assignment_assign_to_condition_spec.rb 0000664 0000000 0000000 00000200645 13070542236 0033676 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::ConditionalAssignment do
subject(:cop) { described_class.new(config) }
let(:config) do
RuboCop::Config.new('Style/ConditionalAssignment' => {
'Enabled' => true,
'SingleLineConditionsOnly' => true,
'IncludeTernaryExpressions' => true,
'EnforcedStyle' => 'assign_to_condition',
'SupportedStyles' => %w[assign_to_condition
assign_inside_condition]
},
'Lint/EndAlignment' => {
'EnforcedStyleAlignWith' => 'keyword',
'Enabled' => true
},
'Metrics/LineLength' => {
'Max' => 80,
'Enabled' => true
})
end
it 'counts array assignment when determining multiple assignment' do
source = ['if foo',
' array[1] = 1',
' a = 1',
'else',
' array[1] = 2',
' a = 2',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows method calls in conditionals' do
source = ['if line.is_a?(String)',
' expect(actual[ix]).to eq(line)',
'else',
' expect(actual[ix]).to match(line)',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows if else without variable assignment' do
source = ['if foo',
' 1',
'else',
' 2',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows assignment to the result of a ternary operation' do
source = 'bar = foo? ? "a" : "b"'
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'registers an offense for assignment in ternary operation' do
source = 'foo? ? bar = "a" : bar = "b"'
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'allows modifier if' do
inspect_source(cop, 'return if a == 1')
expect(cop.offenses).to be_empty
end
it 'allows modifier if inside of if else' do
source = ['if foo',
' a unless b',
'else',
' c unless d',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it "doesn't crash when assignment statement uses chars which have " \
'special meaning in a regex' do
# regression test; see GH issue 2876
source = ['if condition',
" default['key-with-dash'] << a",
'else',
" default['key-with-dash'] << b",
'end']
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
shared_examples 'comparison methods' do |method|
it 'registers an offense for comparison methods in if else' do
source = ['if foo',
" a #{method} b",
'else',
" a #{method} d",
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for comparison methods in unless else' do
source = ['unless foo',
" a #{method} b",
'else',
" a #{method} d",
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for comparison methods in case when' do
source = ['case foo',
'when bar',
" a #{method} b",
'else',
" a #{method} d",
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
end
it_behaves_like('comparison methods', '==')
it_behaves_like('comparison methods', '!=')
it_behaves_like('comparison methods', '=~')
it_behaves_like('comparison methods', '!~')
it_behaves_like('comparison methods', '<=>')
context 'empty branch' do
it 'allows an empty if statement' do
source = ['if foo',
' # comment',
'else',
' do_something',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows an empty elsif statement' do
source = ['if foo',
' bar = 1',
'elsif baz',
' # empty',
'else',
' bar = 2',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows if elsif without else' do
source = ['if foo',
" bar = 'some string'",
'elsif bar',
" bar = 'another string'",
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows assignment in if without an else' do
source = ['if foo',
' bar = 1',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows assignment in unless without an else' do
source = ['unless foo',
' bar = 1',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows assignment in case when without an else' do
source = ['case foo',
'when "a"',
' bar = 1',
'when "b"',
' bar = 2',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows an empty when branch with an else' do
source = ['case foo',
'when "a"',
' # empty',
'when "b"',
' bar = 2',
'else',
' bar = 3',
'end']
inspect_source(cop, source)
expect(cop.messages).to be_empty
end
it 'allows case with an empty else' do
source = ['case foo',
'when "b"',
' bar = 2',
'else',
' # empty',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
it 'allows assignment of different variables in if else' do
source = ['if foo',
' bar = 1',
'else',
' baz = 1',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows method calls in if else' do
source = ['if foo',
' bar',
'else',
' baz',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows if elsif else with the same assignment only in if else' do
source = ['if foo',
' bar = 1',
'elsif foobar',
' baz = 2',
'else',
' bar = 1',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows if elsif else with the same assignment only in if elsif' do
source = ['if foo',
' bar = 1',
'elsif foobar',
' bar = 2',
'else',
' baz = 1',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows if elsif else with the same assignment only in elsif else' do
source = ['if foo',
' bar = 1',
'elsif foobar',
' baz = 2',
'else',
' baz = 1',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows assignment using different operators in if else' do
source = ['if foo',
' bar = 1',
'else',
' bar << 2',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows assignment using different (method) operators in if..else' do
source = ['if foo',
' bar[index] = 1',
'else',
' bar << 2',
'end']
inspect_source(cop, source)
expect(cop.messages).to be_empty
end
it 'allows aref assignment with different indices in if..else' do
source = ['if foo',
' bar[1] = 1',
'else',
' bar[2] = 2',
'end']
inspect_source(cop, source)
expect(cop.messages).to be_empty
end
it 'allows assignment using different operators in if elsif else' do
source = ['if foo',
' bar = 1',
'elsif foobar',
' bar += 2',
'else',
' bar << 3',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows assignment of different variables in case when else' do
source = ['case foo',
'when "a"',
' bar = 1',
'else',
' baz = 2',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
context 'correction would exceed max line length' do
it 'allows assignment to the same variable in if else if the correction ' \
'would create a line longer than the configured LineLength' do
source = ['if foo',
" #{'a' * 78}",
' bar = 1',
'else',
' bar = 2',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows assignment to the same variable in if else if the correction ' \
'would cause the condition to exceed the configured LineLength' do
source = ["if #{'a' * 78}",
' bar = 1',
'else',
' bar = 2',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows assignment to the same variable in case when else if the ' \
'correction would create a line longer than the configured LineLength' do
source = ['case foo',
'when foobar',
" #{'a' * 78}",
' bar = 1',
'else',
' bar = 2',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
shared_examples 'all variable types' do |variable|
it 'registers an offense assigning any variable type in ternary' do
inspect_source(cop, "foo? ? #{variable} = 1 : #{variable} = 2")
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense assigning any variable type in if else' do
source = ['if foo',
" #{variable} = 1",
'else',
" #{variable} = 2",
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense assigning any variable type in case when' do
source = ['case foo',
'when "a"',
" #{variable} = 1",
'else',
" #{variable} = 2",
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'allows assignment to the return of if else' do
source = ["#{variable} = if foo",
' 1',
' else',
' 2',
' end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows assignment to the return of case when' do
source = ["#{variable} = case foo",
' when bar',
' 1',
' else',
' 2',
' end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows assignment to the return of a ternary' do
inspect_source(cop, "#{variable} = foo? ? 1 : 2")
expect(cop.offenses).to be_empty
end
end
it_behaves_like('all variable types', 'bar')
it_behaves_like('all variable types', 'BAR')
it_behaves_like('all variable types', 'FOO::BAR')
it_behaves_like('all variable types', '@bar')
it_behaves_like('all variable types', '@@bar')
it_behaves_like('all variable types', '$BAR')
it_behaves_like('all variable types', 'foo.bar')
shared_examples 'all assignment types' do |assignment|
{ 'local variable' => 'bar',
'constant' => 'CONST',
'class variable' => '@@cvar',
'instance variable' => '@ivar',
'global variable' => '$gvar' }.each do |type, name|
context "for a #{type} lval" do
it "registers an offense for assignment using #{assignment} " \
'in ternary' do
source = "foo? ? #{name} #{assignment} 1 : #{name} #{assignment} 2"
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it "allows assignment using #{assignment} to ternary" do
source = "#{name} #{assignment} foo? ? 1 : 2"
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it "registers an offense for assignment using #{assignment} in " \
'if else' do
source = ['if foo',
" #{name} #{assignment} 1",
'else',
" #{name} #{assignment} 2",
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it "registers an offense for assignment using #{assignment} in "\
' case when' do
source = ['case foo',
'when "a"',
" #{name} #{assignment} 1",
'else',
" #{name} #{assignment} 2",
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it "autocorrects for assignment using #{assignment} in if else" do
source = ['if foo',
" #{name} #{assignment} 1",
'else',
" #{name} #{assignment} 2",
'end']
new_source = autocorrect_source(cop, source)
indent = ' ' * "#{name} #{assignment} ".length
expect(new_source).to eq ["#{name} #{assignment} if foo",
' 1',
'else',
' 2',
"#{indent}end"].join("\n")
end
end
end
end
it_behaves_like('all assignment types', '=')
it_behaves_like('all assignment types', '==')
it_behaves_like('all assignment types', '===')
it_behaves_like('all assignment types', '+=')
it_behaves_like('all assignment types', '-=')
it_behaves_like('all assignment types', '*=')
it_behaves_like('all assignment types', '**=')
it_behaves_like('all assignment types', '/=')
it_behaves_like('all assignment types', '%=')
it_behaves_like('all assignment types', '^=')
it_behaves_like('all assignment types', '&=')
it_behaves_like('all assignment types', '|=')
it_behaves_like('all assignment types', '<=')
it_behaves_like('all assignment types', '>=')
it_behaves_like('all assignment types', '<<=')
it_behaves_like('all assignment types', '>>=')
it_behaves_like('all assignment types', '||=')
it_behaves_like('all assignment types', '&&=')
it_behaves_like('all assignment types', '+=')
it_behaves_like('all assignment types', '<<')
it_behaves_like('all assignment types', '-=')
it 'registers an offense for assignment in if elsif else' do
source = ['if foo',
' bar = 1',
'elsif baz',
' bar = 2',
'else',
' bar = 3',
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for assignment in if elsif elsif else' do
source = ['if foo',
' bar = 1',
'elsif baz',
' bar = 2',
'elsif foobar',
' bar = 3',
'else',
' bar = 4',
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for assignment in if else when the assignment ' \
'spans multiple lines' do
source = ['if foo',
' foo = {',
' a: 1,',
' b: 2,',
' c: 2,',
' d: 2,',
' e: 2,',
' f: 2,',
' g: 2,',
' h: 2',
' }',
'else',
' foo = { }',
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'autocorrects assignment in if else when the assignment ' \
'spans multiple lines' do
source = ['if foo',
' foo = {',
' a: 1,',
' b: 2,',
' c: 2,',
' d: 2,',
' e: 2,',
' f: 2,',
' g: 2,',
' h: 2',
' }',
'else',
' foo = { }',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['foo = if foo',
' {',
' a: 1,',
' b: 2,',
' c: 2,',
' d: 2,',
' e: 2,',
' f: 2,',
' g: 2,',
' h: 2',
' }',
'else',
' { }',
' end'].join("\n"))
end
context 'assignment as the last statement' do
it 'allows more than variable assignment in if else' do
source = ['if foo',
' method_call',
' bar = 1',
'else',
' method_call',
' bar = 2',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows more than variable assignment in if elsif else' do
source = ['if foo',
' method_call',
' bar = 1',
'elsif foobar',
' method_call',
' bar = 2',
'else',
' method_call',
' bar = 3',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows multiple assignment in if else' do
source = ['if baz',
' foo = 1',
' bar = 1',
'else',
' foo = 2',
' bar = 2',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows multiple assignment in if elsif else' do
source = ['if baz',
' foo = 1',
' bar = 1',
'elsif foobar',
' foo = 2',
' bar = 2',
'else',
' foo = 3',
' bar = 3',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows multiple assignment in if elsif elsif else' do
source = ['if baz',
' foo = 1',
' bar = 1',
'elsif foobar',
' foo = 2',
' bar = 2',
'elsif barfoo',
' foo = 3',
' bar = 3',
'else',
' foo = 4',
' bar = 4',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows multiple assignment in if elsif else when the last ' \
'assignment is the same and the earlier assignments do not appear in ' \
'all branches' do
source = ['if baz',
' foo = 1',
' bar = 1',
'elsif foobar',
' baz = 2',
' bar = 2',
'else',
' boo = 3',
' bar = 3',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows multiple assignment in case when else when the last ' \
'assignment is the same and the earlier assignments do not appear ' \
'in all branches' do
source = ['case foo',
'when foobar',
' baz = 1',
' bar = 1',
'when foobaz',
' boo = 2',
' bar = 2',
'else',
' faz = 3',
' bar = 3',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows out of order multiple assignment in if elsif else' do
source = ['if baz',
' bar = 1',
' foo = 1',
'elsif foobar',
' foo = 2',
' bar = 2',
'else',
' foo = 3',
' bar = 3',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows multiple assignment in unless else' do
source = ['unless baz',
' foo = 1',
' bar = 1',
'else',
' foo = 2',
' bar = 2',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows multiple assignments in case when with only one when' do
source = ['case foo',
'when foobar',
' foo = 1',
' bar = 1',
'else',
' foo = 3',
' bar = 3',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows multiple assignments in case when with multiple whens' do
source = ['case foo',
'when foobar',
' foo = 1',
' bar = 1',
'when foobaz',
' foo = 2',
' bar = 2',
'else',
' foo = 3',
' bar = 3',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows multiple assignments in case when if there are uniq ' \
'variables in the when branches' do
source = ['case foo',
'when foobar',
' foo = 1',
' baz = 1',
' bar = 1',
'when foobaz',
' foo = 2',
' baz = 2',
' bar = 2',
'else',
' foo = 3',
' bar = 3',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows multiple assignment in case statements when the last ' \
'assignment is the same and the earlier assignments do not appear in ' \
'all branches' do
source = ['case foo',
'when foobar',
' foo = 1',
' bar = 1',
'when foobaz',
' baz = 2',
' bar = 2',
'else',
' boo = 3',
' bar = 3',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows assignment in if elsif else with some branches only ' \
'containing variable assignment and others containing more than ' \
'variable assignment' do
source = ['if foo',
' bar = 1',
'elsif foobar',
' method_call',
' bar = 2',
'elsif baz',
' bar = 3',
'else',
' method_call',
' bar = 4',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows variable assignment in unless else with more than ' \
'variable assignment' do
source = ['unless foo',
' method_call',
' bar = 1',
'else',
' method_call',
' bar = 2',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows variable assignment in case when else with more than ' \
'variable assignment' do
source = ['case foo',
'when foobar',
' method_call',
' bar = 1',
'else',
' method_call',
' bar = 2',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
context 'multiple assignment in only one branch' do
it 'allows multiple assignment is in if' do
source = ['if foo',
' baz = 1',
' bar = 1',
'elsif foobar',
' method_call',
' bar = 2',
'else',
' other_method',
' bar = 3',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows multiple assignment is in elsif' do
source = ['if foo',
' method_call',
' bar = 1',
'elsif foobar',
' baz = 2',
' bar = 2',
'else',
' other_method',
' bar = 3',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'registers an offense when multiple assignment is in else' do
source = ['if foo',
' method_call',
' bar = 1',
'elsif foobar',
' other_method',
' bar = 2',
'else',
' baz = 3',
' bar = 3',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
it 'registers an offense for assignment in if then else' do
source = ['if foo then bar = 1',
'else bar = 2',
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for assignment in unless else' do
source = ['unless foo',
' bar = 1',
'else',
' bar = 2',
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for assignment in case when then else' do
source = ['case foo',
'when bar then baz = 1',
'else baz = 2',
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for assignment in case with when when else' do
source = ['case foo',
'when foobar',
' bar = 1',
'when baz',
' bar = 2',
'else',
' bar = 3',
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'allows different assignment types in case with when when else' do
source = ['case foo',
'when foobar',
' bar = 1',
'else',
' bar << 2',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows assignment in multiple branches when it is ' \
'wrapped in a modifier' do
source = ['if foo',
' bar << 1',
'else',
' bar << 2 if foobar',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
context 'auto-correct' do
shared_examples 'comparison correction' do |method|
it 'corrects comparison methods in if elsif else' do
source = ['if foo',
" a #{method} b",
'elsif bar',
" a #{method} c",
'else',
" a #{method} d",
'end']
new_source = autocorrect_source(cop, source)
indent = ' ' * "a #{method} ".length
expect(new_source).to eq(["a #{method} if foo",
' b',
'elsif bar',
' c',
'else',
' d',
"#{indent}end"].join("\n"))
end
it 'corrects comparison methods in unless else' do
source = ['unless foo',
" a #{method} b",
'else',
" a #{method} d",
'end']
new_source = autocorrect_source(cop, source)
indent = ' ' * "a #{method} ".length
expect(new_source).to eq(["a #{method} unless foo",
' b',
'else',
' d',
"#{indent}end"].join("\n"))
end
it 'corrects comparison methods in case when' do
source = ['case foo',
'when bar',
" a #{method} b",
'else',
" a #{method} d",
'end']
new_source = autocorrect_source(cop, source)
indent = ' ' * "a #{method} ".length
expect(new_source).to eq(["a #{method} case foo",
'when bar',
' b',
'else',
' d',
"#{indent}end"].join("\n"))
end
end
it_behaves_like('comparison correction', '==')
it_behaves_like('comparison correction', '!=')
it_behaves_like('comparison correction', '=~')
it_behaves_like('comparison correction', '!~')
it_behaves_like('comparison correction', '<=>')
it 'corrects assignment in ternary operations' do
new_source = autocorrect_source(cop, 'foo? ? bar = 1 : bar = 2')
expect(new_source).to eq('bar = foo? ? 1 : 2')
end
it 'corrects assignment in ternary operations using strings' do
new_source = autocorrect_source(cop, 'foo? ? bar = "1" : bar = "2"')
expect(new_source).to eq('bar = foo? ? "1" : "2"')
end
it 'corrects =~ in ternary operations' do
new_source = autocorrect_source(cop, 'foo? ? bar =~ /a/ : bar =~ /b/')
expect(new_source).to eq('bar =~ (foo? ? /a/ : /b/)')
end
it 'corrects aref assignment in ternary operations' do
new_source = autocorrect_source(cop, 'foo? ? bar[1] = 1 : bar[1] = 2')
expect(new_source).to eq('bar[1] = foo? ? 1 : 2')
end
it 'corrects << in ternary operations' do
new_source = autocorrect_source(cop, 'foo? ? bar << 1 : bar << 2')
expect(new_source).to eq('bar << (foo? ? 1 : 2)')
end
it 'corrects assignment in if else' do
source = ['if foo',
' bar = 1',
'else',
' bar = 2',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['bar = if foo',
' 1',
'else',
' 2',
' end'].join("\n"))
end
it 'corrects assignment in if elsif else' do
source = ['if foo',
' bar = 1',
'elsif baz',
' bar = 2',
'else',
' bar = 3',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['bar = if foo',
' 1',
'elsif baz',
' 2',
'else',
' 3',
' end'].join("\n"))
end
shared_examples '2 character assignment types' do |asgn|
it "corrects assignment using #{asgn} in if elsif else" do
source = ['if foo',
" bar #{asgn} 1",
'elsif baz',
" bar #{asgn} 2",
'else',
" bar #{asgn} 3",
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(["bar #{asgn} if foo",
' 1',
'elsif baz',
' 2',
'else',
' 3',
' end'].join("\n"))
end
it "corrects assignment using #{asgn} in case when else" do
source = ['case foo',
'when bar',
" baz #{asgn} 1",
'else',
" baz #{asgn} 2",
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(["baz #{asgn} case foo",
'when bar',
' 1',
'else',
' 2',
' end'].join("\n"))
end
it "corrects assignment using #{asgn} in unless else" do
source = ['unless foo',
" bar #{asgn} 1",
'else',
" bar #{asgn} 2",
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(["bar #{asgn} unless foo",
' 1',
'else',
' 2',
' end'].join("\n"))
end
end
it_behaves_like('2 character assignment types', '+=')
it_behaves_like('2 character assignment types', '-=')
it_behaves_like('2 character assignment types', '<<')
shared_examples '3 character assignment types' do |asgn|
it "corrects assignment using #{asgn} in if elsif else" do
source = ['if foo',
" bar #{asgn} 1",
'elsif baz',
" bar #{asgn} 2",
'else',
" bar #{asgn} 3",
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(["bar #{asgn} if foo",
' 1',
'elsif baz',
' 2',
'else',
' 3',
' end'].join("\n"))
end
it "corrects assignment using #{asgn} in case when else" do
source = ['case foo',
'when bar',
" baz #{asgn} 1",
'else',
" baz #{asgn} 2",
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(["baz #{asgn} case foo",
'when bar',
' 1',
'else',
' 2',
' end'].join("\n"))
end
it "corrects assignment using #{asgn} in unless else" do
source = ['unless foo',
" bar #{asgn} 1",
'else',
" bar #{asgn} 2",
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(["bar #{asgn} unless foo",
' 1',
'else',
' 2',
' end'].join("\n"))
end
end
it_behaves_like('3 character assignment types', '&&=')
it_behaves_like('3 character assignment types', '||=')
it 'corrects assignment in if elsif else with multiple elsifs' do
source = ['if foo',
' bar = 1',
'elsif baz',
' bar = 2',
'elsif foobar',
' bar = 3',
'else',
' bar = 4',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['bar = if foo',
' 1',
'elsif baz',
' 2',
'elsif foobar',
' 3',
'else',
' 4',
' end'].join("\n"))
end
it 'corrects assignment in unless else' do
source = ['unless foo',
' bar = 1',
'else',
' bar = 2',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['bar = unless foo',
' 1',
'else',
' 2',
' end'].join("\n"))
end
it 'corrects assignment in case when else' do
source = ['case foo',
'when bar',
' baz = 1',
'else',
' baz = 2',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['baz = case foo',
'when bar',
' 1',
'else',
' 2',
' end'].join("\n"))
end
it 'corrects assignment in case when else with multiple whens' do
source = ['case foo',
'when bar',
' baz = 1',
'when foobar',
' baz = 2',
'else',
' baz = 3',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['baz = case foo',
'when bar',
' 1',
'when foobar',
' 2',
'else',
' 3',
' end'].join("\n"))
end
context 'assignment from a method' do
it 'corrects if else' do
source = ['if foo?(scope.node)',
' bar << foobar(var, all)',
'else',
' bar << baz(var, all)',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['bar << if foo?(scope.node)',
' foobar(var, all)',
'else',
' baz(var, all)',
' end'].join("\n"))
end
it 'corrects unless else' do
source = ['unless foo?(scope.node)',
' bar << foobar(var, all)',
'else',
' bar << baz(var, all)',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['bar << unless foo?(scope.node)',
' foobar(var, all)',
'else',
' baz(var, all)',
' end'].join("\n"))
end
it 'corrects case when' do
source = ['case foo',
'when foobar',
' bar << foobar(var, all)',
'else',
' bar << baz(var, all)',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['bar << case foo',
'when foobar',
' foobar(var, all)',
'else',
' baz(var, all)',
' end'].join("\n"))
end
end
context 'then' do
it 'corrects if then elsif then else' do
source = ['if cond then bar = 1',
'elsif cond then bar = 2',
'else bar = 3',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['bar = if cond then 1',
'elsif cond then 2',
'else 3',
' end'].join("\n"))
end
it 'corrects case when then else' do
source = ['case foo',
'when baz then bar = 1',
'else bar = 2',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['bar = case foo',
'when baz then 1',
'else 2',
' end'].join("\n"))
end
end
it 'preserves comments during correction in if else' do
source = ['if foo',
' # comment in if',
' bar = 1',
'else',
' # comment in else',
' bar = 2',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['bar = if foo',
' # comment in if',
' 1',
'else',
' # comment in else',
' 2',
' end'].join("\n"))
end
it 'preserves comments during correction in case when else' do
source = ['case foo',
'when foobar',
' # comment in when',
' bar = 1',
'else',
' # comment in else',
' bar = 2',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['bar = case foo',
'when foobar',
' # comment in when',
' 1',
'else',
' # comment in else',
' 2',
' end'].join("\n"))
end
context 'aref assignment' do
it 'corrects if..else' do
new_source = autocorrect_source(cop, ['if something',
' array[1] = 1',
'else',
' array[1] = 2',
'end'])
expect(new_source).to eq(['array[1] = if something',
' 1',
'else',
' 2',
' end'].join("\n"))
end
context 'with different indices' do
it "doesn't register an offense" do
inspect_source(cop, ['if something',
' array[1, 2] = 1',
'else',
' array[1, 3] = 2',
'end'])
expect(cop.offenses).to be_empty
end
end
end
context 'self.attribute= assignment' do
it 'corrects if..else' do
new_source = autocorrect_source(cop, ['if something',
' self.attribute = 1',
'else',
' self.attribute = 2',
'end'])
expect(new_source).to eq(['self.attribute = if something',
' 1',
'else',
' 2',
' end'].join("\n"))
end
context 'with different receivers' do
it "doesn't register an offense" do
inspect_source(cop, ['if something',
' obj1.attribute = 1',
'else',
' obj2.attribute = 2',
'end'])
expect(cop.offenses).to be_empty
end
end
end
context 'multiple assignment' do
it 'does not register an offense in if else' do
inspect_source(cop, ['if something',
' a, b = 1, 2',
'else',
' a, b = 2, 1',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense in case when' do
inspect_source(cop, ['case foo',
'when bar',
' a, b = 1, 2',
'else',
' a, b = 2, 1',
'end'])
expect(cop.offenses).to be_empty
end
end
end
context 'configured to check conditions with multiple statements' do
subject(:cop) { described_class.new(config) }
let(:config) do
RuboCop::Config.new('Style/ConditionalAssignment' => {
'Enabled' => true,
'SingleLineConditionsOnly' => false,
'IncludeTernaryExpressions' => true,
'EnforcedStyle' => 'assign_to_condition',
'SupportedStyles' => %w[assign_to_condition
assign_inside_condition]
},
'Lint/EndAlignment' => {
'EnforcedStyleAlignWith' => 'keyword',
'Enabled' => true
},
'Metrics/LineLength' => {
'Max' => 80,
'Enabled' => true
})
end
context 'assignment as the last statement' do
it 'registers an offense in if else with more than variable assignment' do
source = ['if foo',
' method_call',
' bar = 1',
'else',
' method_call',
' bar = 2',
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense in if elsif else with more than ' \
'variable assignment' do
source = ['if foo',
' method_call',
' bar = 1',
'elsif foobar',
' method_call',
' bar = 2',
'else',
' method_call',
' bar = 3',
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'register an offense for multiple assignment in if else' do
source = ['if baz',
' foo = 1',
' bar = 1',
'else',
' foo = 2',
' bar = 2',
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for multiple assignment in if elsif else' do
source = ['if baz',
' foo = 1',
' bar = 1',
'elsif foobar',
' foo = 2',
' bar = 2',
'else',
' foo = 3',
' bar = 3',
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'allows multiple assignment in if elsif elsif else' do
source = ['if baz',
' foo = 1',
' bar = 1',
'elsif foobar',
' foo = 2',
' bar = 2',
'elsif barfoo',
' foo = 3',
' bar = 3',
'else',
' foo = 4',
' bar = 4',
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'allows out of order multiple assignment in if elsif else' do
source = ['if baz',
' bar = 1',
' foo = 1',
'elsif foobar',
' foo = 2',
' bar = 2',
'else',
' foo = 3',
' bar = 3',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows multiple assignment in unless else' do
source = ['unless baz',
' foo = 1',
' bar = 1',
'else',
' foo = 2',
' bar = 2',
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'allows multiple assignments in case when with only one when' do
source = ['case foo',
'when foobar',
' foo = 1',
' bar = 1',
'else',
' foo = 3',
' bar = 3',
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'allows multiple assignments in case when with multiple whens' do
source = ['case foo',
'when foobar',
' foo = 1',
' bar = 1',
'when foobaz',
' foo = 2',
' bar = 2',
'else',
' foo = 3',
' bar = 3',
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense in if elsif else with some branches only ' \
'containing variable assignment and others containing more than ' \
'variable assignment' do
source = ['if foo',
' bar = 1',
'elsif foobar',
' method_call',
' bar = 2',
'elsif baz',
' bar = 3',
'else',
' method_call',
' bar = 4',
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense in unless else with more than ' \
'variable assignment' do
source = ['unless foo',
' method_call',
' bar = 1',
'else',
' method_call',
' bar = 2',
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense in case when else with more than ' \
'variable assignment' do
source = ['case foo',
'when foobar',
' method_call',
' bar = 1',
'else',
' method_call',
' bar = 2',
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
context 'multiple assignment in only one branch' do
it 'registers an offense when multiple assignment is in if' do
source = ['if foo',
' baz = 1',
' bar = 1',
'elsif foobar',
' method_call',
' bar = 2',
'else',
' other_method',
' bar = 3',
'end']
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense when multiple assignment is in elsif' do
source = ['if foo',
' method_call',
' bar = 1',
'elsif foobar',
' baz = 2',
' bar = 2',
'else',
' other_method',
' bar = 3',
'end']
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense when multiple assignment is in else' do
source = ['if foo',
' method_call',
' bar = 1',
'elsif foobar',
' other_method',
' bar = 2',
'else',
' baz = 3',
' bar = 3',
'end']
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
end
end
it 'allows assignment in multiple branches when it is ' \
'wrapped in a modifier' do
source = ['if foo',
' bar << 1',
' bar << 2',
'else',
' bar << 3',
' bar << 4 if foobar',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'registers an offense for multiple assignment when an earlier ' \
'assignment is is protected by a modifier' do
source = ['if foo',
' bar << 1',
' bar << 2',
'else',
' bar << 3 if foobar',
' bar << 4',
'end']
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
context 'auto-correct' do
it 'corrects multiple assignment in if else' do
source = ['if foo',
' baz = 1',
' bar = 1',
'else',
' baz = 3',
' bar = 3',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['bar = if foo',
' baz = 1',
' 1',
'else',
' baz = 3',
' 3',
' end'].join("\n"))
end
it 'corrects multiple assignment in if elsif else' do
source = ['if foo',
' baz = 1',
' bar = 1',
'elsif foobar',
' baz = 2',
' bar = 2',
'else',
' baz = 3',
' bar = 3',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['bar = if foo',
' baz = 1',
' 1',
'elsif foobar',
' baz = 2',
' 2',
'else',
' baz = 3',
' 3',
' end'].join("\n"))
end
it 'corrects multiple assignment in if elsif else with multiple elsifs' do
source = ['if foo',
' baz = 1',
' bar = 1',
'elsif foobar',
' baz = 2',
' bar = 2',
'elsif foobaz',
' baz = 3',
' bar = 3',
'else',
' baz = 4',
' bar = 4',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['bar = if foo',
' baz = 1',
' 1',
'elsif foobar',
' baz = 2',
' 2',
'elsif foobaz',
' baz = 3',
' 3',
'else',
' baz = 4',
' 4',
' end'].join("\n"))
end
it 'corrects multiple assignment in case when' do
source = ['case foo',
'when foobar',
' baz = 1',
' bar = 1',
'else',
' baz = 2',
' bar = 2',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['bar = case foo',
'when foobar',
' baz = 1',
' 1',
'else',
' baz = 2',
' 2',
' end'].join("\n"))
end
it 'corrects multiple assignment in case when with multiple whens' do
source = ['case foo',
'when foobar',
' baz = 1',
' bar = 1',
'when foobaz',
' baz = 2',
' bar = 2',
'else',
' baz = 3',
' bar = 3',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['bar = case foo',
'when foobar',
' baz = 1',
' 1',
'when foobaz',
' baz = 2',
' 2',
'else',
' baz = 3',
' 3',
' end'].join("\n"))
end
it 'corrects multiple assignment in unless else' do
source = ['unless foo',
' baz = 1',
' bar = 1',
'else',
' baz = 2',
' bar = 2',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['bar = unless foo',
' baz = 1',
' 1',
'else',
' baz = 2',
' 2',
' end'].join("\n"))
end
it 'corrects assignment in an if statement that is nested ' \
'in unless else' do
source = ['unless foo',
' if foobar',
' baz = 1',
' elsif qux',
' baz = 2',
' else',
' baz = 3',
' end',
'else',
' baz = 4',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['unless foo',
' baz = if foobar',
' 1',
' elsif qux',
' 2',
' else',
' 3',
' end',
'else',
' baz = 4',
'end'].join("\n"))
end
end
end
context 'EndAlignment configured to start_of_line' do
subject(:cop) { described_class.new(config) }
let(:config) do
RuboCop::Config.new('Style/ConditionalAssignment' => {
'Enabled' => true,
'SingleLineConditionsOnly' => false,
'IncludeTernaryExpressions' => true
},
'Lint/EndAlignment' => {
'EnforcedStyleAlignWith' => 'start_of_line',
'Enabled' => true
},
'Metrics/LineLength' => {
'Max' => 80,
'Enabled' => true
})
context 'auto-correct' do
it 'uses proper end alignment in if' do
source = ['if foo',
' a = b',
'elsif bar',
' a = c',
'else',
' a = d',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['a = if foo',
' b',
'elsif bar',
' c',
'else',
' d',
'end'].join("\n"))
end
it 'uses proper end alignment in unless' do
source = ['unless foo',
' a = b',
'else',
' a = d',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['a = unless foo',
' b',
'else',
' d',
'end'].join("\n"))
end
it 'uses proper end alignment in case' do
source = ['case foo',
'when bar',
' a = b',
'when baz',
' a = c',
'else',
' a = d',
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['a = case foo',
'when bar',
' b',
'when baz',
' c',
'else',
' d',
'end'].join("\n"))
end
end
end
end
context 'IncludeTernaryExpressions false' do
let(:config) do
RuboCop::Config.new('Style/ConditionalAssignment' => {
'Enabled' => true,
'SingleLineConditionsOnly' => true,
'IncludeTernaryExpressions' => false,
'EnforcedStyle' => 'assign_to_condition',
'SupportedStyles' => %w[assign_to_condition
assign_inside_condition]
},
'Lint/EndAlignment' => {
'EnforcedStyleAlignWith' => 'keyword',
'Enabled' => true
},
'Metrics/LineLength' => {
'Max' => 80,
'Enabled' => true
})
end
it 'allows assignment in ternary operation' do
source = 'foo? ? bar = "a" : bar = "b"'
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/constant_name_spec.rb 0000664 0000000 0000000 00000003346 13070542236 0025657 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::ConstantName do
subject(:cop) { described_class.new }
it 'registers an offense for camel case in const name' do
inspect_source(cop,
'TopCase = 5')
expect(cop.offenses.size).to eq(1)
end
it 'registers offenses for camel case in multiple const assignment' do
inspect_source(cop,
'TopCase, Test2, TEST_3 = 5, 6, 7')
expect(cop.offenses.size).to eq(2)
end
it 'registers an offense for snake case in const name' do
inspect_source(cop,
'TOP_test = 5')
expect(cop.offenses.size).to eq(1)
end
it 'allows screaming snake case in const name' do
inspect_source(cop,
'TOP_TEST = 5')
expect(cop.offenses).to be_empty
end
it 'allows screaming snake case in multiple const assignment' do
inspect_source(cop,
'TOP_TEST, TEST_2 = 5, 6')
expect(cop.offenses).to be_empty
end
it 'does not check names if rhs is a method call' do
inspect_source(cop,
'AnythingGoes = test')
expect(cop.offenses).to be_empty
end
it 'does not check names if rhs is a method call with block' do
inspect_source(cop,
['AnythingGoes = test do',
' do_something',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not check if rhs is another constant' do
inspect_source(cop,
'Parser::CurrentRuby = Parser::Ruby20')
expect(cop.offenses).to be_empty
end
it 'checks qualified const names' do
inspect_source(cop,
['::AnythingGoes = 30',
'a::Bar_foo = 10'])
expect(cop.offenses.size).to eq(2)
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/copyright_spec.rb 0000664 0000000 0000000 00000014476 13070542236 0025044 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
def unindent(s)
s.gsub(/^#{s.scan(/^[ \t]+(?=\S)/).min}/, '')
end
def expect_no_copyright_offense(cop, source)
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
def expect_copyright_offense(cop, source)
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.messages[0]).to eq(cop.message)
end
describe RuboCop::Cop::Style::Copyright, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'Notice' => 'Copyright (\(c\) )?2015 Acme Inc' } }
context 'when the copyright notice is present' do
let(:source) { unindent(<<-SOURCE) }
# Copyright 2015 Acme Inc.
# test2
names = Array.new
names << 'James'
SOURCE
it 'does not add an offense' do
expect_no_copyright_offense(cop, source)
end
end
context 'when the copyright notice is not the first comment' do
let(:source) { unindent(<<-SOURCE) }
# test2
# Copyright 2015 Acme Inc.
names = Array.new
names << 'James'
SOURCE
it 'does not add an offense' do
expect_no_copyright_offense(cop, source)
end
end
context 'when the copyright notice is in a block comment' do
let(:source) { unindent(<<-SOURCE) }
=begin
blah, blah, blah
Copyright 2015 Acme Inc.
=end
names = Array.new
names << 'James'
SOURCE
it 'does not add an offense' do
expect_no_copyright_offense(cop, source)
end
end
context 'when the copyright notice is missing' do
let(:source) { unindent(<<-SOURCE) }
# test
# test2
names = Array.new
names << 'James'
SOURCE
it 'adds an offense' do
expect_copyright_offense(cop, source)
end
let(:expected_autocorrected_source) { unindent(<<-SOURCE) }
# Copyright (c) 2015 Acme Inc.
# test
# test2
names = Array.new
names << 'James'
SOURCE
it 'correctly autocorrects the source code' do
cop_config['AutocorrectNotice'] = '# Copyright (c) 2015 Acme Inc.'
autocorrected_source = autocorrect_source(cop, source)
expect(autocorrected_source).to eq(expected_autocorrected_source)
end
it 'fails to autocorrect when the AutocorrectNotice does ' \
'not match the Notice pattern' do
cop_config['AutocorrectNotice'] = '# Copyleft (c) 2015 Acme Inc.'
expect do
autocorrect_source(cop, source)
end.to raise_error(RuboCop::Warning)
end
it 'fails to autocorrect if no AutocorrectNotice is given' do
# cop_config['AutocorrectNotice'] = '# Copyleft (c) 2015 Acme Inc.'
expect do
autocorrect_source(cop, source)
end.to raise_error(RuboCop::Warning)
end
end
context 'when the copyright notice comes after any code' do
let(:source) { unindent(<<-SOURCE) }
# test2
names = Array.new
# Copyright (c) 2015 Acme Inc.
names << 'James'
SOURCE
it 'adds an offense' do
expect_copyright_offense(cop, source)
end
let(:expected_autocorrected_source) { unindent(<<-SOURCE) }
# Copyright (c) 2015 Acme Inc.
# test2
names = Array.new
# Copyright (c) 2015 Acme Inc.
names << 'James'
SOURCE
it 'correctly autocorrects the source code' do
cop_config['AutocorrectNotice'] = '# Copyright (c) 2015 Acme Inc.'
autocorrected_source = autocorrect_source(cop, source)
expect(autocorrected_source).to eq(expected_autocorrected_source)
end
end
context 'when the source code file is empty' do
let(:source) { '' }
it 'adds an offense' do
expect_copyright_offense(cop, source)
end
let(:expected_autocorrected_source) { "# Copyright (c) 2015 Acme Inc.\n" }
it 'correctly autocorrects the source code' do
cop_config['AutocorrectNotice'] = '# Copyright (c) 2015 Acme Inc.'
autocorrected_source = autocorrect_source(cop, source)
expect(autocorrected_source).to eq(expected_autocorrected_source)
end
end
context 'when the copyright notice is missing and ' \
'the source code file starts with a shebang' do
let(:source) { unindent(<<-SOURCE) }
#!/usr/bin/env ruby
names = Array.new
names << 'James'
SOURCE
it 'adds an offense' do
expect_copyright_offense(cop, source)
end
let(:expected_autocorrected_source) { unindent(<<-SOURCE) }
#!/usr/bin/env ruby
# Copyright (c) 2015 Acme Inc.
names = Array.new
names << 'James'
SOURCE
it 'correctly autocorrects the source code' do
cop_config['AutocorrectNotice'] = '# Copyright (c) 2015 Acme Inc.'
autocorrected_source = autocorrect_source(cop, source)
expect(autocorrected_source).to eq(expected_autocorrected_source)
end
end
context 'when the copyright notice is missing and ' \
'the source code file starts with an encoding comment' do
let(:source) { unindent(<<-SOURCE) }
# encoding: utf-8
names = Array.new
names << 'James'
SOURCE
it 'adds an offense' do
expect_copyright_offense(cop, source)
end
let(:expected_autocorrected_source) { unindent(<<-SOURCE) }
# encoding: utf-8
# Copyright (c) 2015 Acme Inc.
names = Array.new
names << 'James'
SOURCE
it 'correctly autocorrects the source code' do
cop_config['AutocorrectNotice'] = '# Copyright (c) 2015 Acme Inc.'
autocorrected_source = autocorrect_source(cop, source)
expect(autocorrected_source).to eq(expected_autocorrected_source)
end
end
context 'when the copyright notice is missing and ' \
'the source code file starts with shebang and ' \
'an encoding comment' do
let(:source) { unindent(<<-SOURCE) }
#!/usr/bin/env ruby
# encoding: utf-8
names = Array.new
names << 'James'
SOURCE
it 'adds an offense' do
expect_copyright_offense(cop, source)
end
let(:expected_autocorrected_source) { unindent(<<-SOURCE) }
#!/usr/bin/env ruby
# encoding: utf-8
# Copyright (c) 2015 Acme Inc.
names = Array.new
names << 'James'
SOURCE
it 'correctly autocorrects the source code' do
cop_config['AutocorrectNotice'] = '# Copyright (c) 2015 Acme Inc.'
autocorrected_source = autocorrect_source(cop, source)
expect(autocorrected_source).to eq(expected_autocorrected_source)
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/def_with_parentheses_spec.rb 0000664 0000000 0000000 00000002171 13070542236 0027213 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::DefWithParentheses do
subject(:cop) { described_class.new }
it 'reports an offense for def with empty parens' do
src = ['def func()',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'reports an offense for class def with empty parens' do
src = ['def Test.func()',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'accepts def with arg and parens' do
src = ['def func(a)',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'accepts empty parentheses in one liners' do
src = "def to_s() join '/' end"
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'auto-removes unneeded parens' do
new_source = autocorrect_source(cop, ['def test();',
'something',
'end'])
expect(new_source).to eq(['def test;',
'something',
'end'].join("\n"))
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/documentation_method_spec.rb 0000664 0000000 0000000 00000047734 13070542236 0027250 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::DocumentationMethod, :config do
subject(:cop) { described_class.new(config) }
before do
inspect_source(cop, source)
end
shared_examples 'code with offense' do |code|
context "when checking #{code}" do
let(:source) { code }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq([message])
end
end
end
shared_examples 'code without offense' do |code|
let(:source) { code }
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
let(:require_for_non_public_methods) { false }
let(:config) do
RuboCop::Config.new(
'Style/CommentAnnotation' => {
'Keywords' => %w[TODO FIXME OPTIMIZE HACK REVIEW]
},
'Style/DocumentationMethod' => {
'RequireForNonPublicMethods' => require_for_non_public_methods
}
)
end
let(:message) { described_class::MSG }
context 'when declaring methods outside a class' do
context 'without documentation comment' do
context 'when method is public' do
it_behaves_like 'code with offense', <<-CODE
def foo
puts 'bar'
end
CODE
it_behaves_like 'code with offense',
'def method; end'
end
context 'when method is private' do
it_behaves_like 'code without offense', <<-CODE
private
def foo
puts 'bar'
end
CODE
it_behaves_like 'code without offense', <<-CODE
private
def foo; end
CODE
it_behaves_like 'code without offense', <<-CODE
private def foo
puts 'bar'
end
CODE
it_behaves_like 'code without offense',
'private def method; end'
context 'when required for non-public methods' do
let(:require_for_non_public_methods) { true }
it_behaves_like 'code with offense', <<-CODE
private
def foo
puts 'bar'
end
CODE
it_behaves_like 'code with offense', <<-CODE
private
def foo; end
CODE
it_behaves_like 'code with offense', <<-CODE
private def foo
puts 'bar'
end
CODE
it_behaves_like 'code with offense',
'private def method; end'
end
end
context 'when method is protected' do
it_behaves_like 'code without offense', <<-CODE
protected
def foo
puts 'bar'
end
CODE
it_behaves_like 'code without offense', <<-CODE
protected def foo
puts 'bar'
end
CODE
context 'when required for non-public methods' do
let(:require_for_non_public_methods) { true }
it_behaves_like 'code with offense', <<-CODE
protected
def foo
puts 'bar'
end
CODE
it_behaves_like 'code with offense', <<-CODE
protected def foo
puts 'bar'
end
CODE
end
end
end
context 'with documentation comment' do
it_behaves_like 'code without offense', <<-CODE
# Documenation
def foo
puts 'bar'
end
CODE
it_behaves_like 'code without offense', <<-CODE
# Documentation
def foo; end
CODE
end
context 'with both public and private methods' do
it_behaves_like 'code with offense', <<-CODE
def foo
puts 'bar'
end
private
def baz
puts 'bar'
end
CODE
it_behaves_like 'code without offense', <<-CODE
# Documenation
def foo
puts 'bar'
end
private
def baz
puts 'bar'
end
CODE
context 'when required for non-public methods' do
let(:require_for_non_public_methods) { true }
it_behaves_like 'code with offense', <<-CODE
# Documenation
def foo
puts 'bar'
end
private
def baz
puts 'bar'
end
CODE
end
end
context 'when declaring methods in a class' do
context 'without documentation comment' do
context 'wheh method is public' do
it_behaves_like 'code with offense', <<-CODE
class Foo
def bar
puts 'baz'
end
end
CODE
it_behaves_like 'code with offense', <<-CODE
class Foo
def method; end
end
CODE
end
context 'when method is private' do
it_behaves_like 'code without offense', <<-CODE
class Foo
private
def bar
puts 'baz'
end
end
CODE
it_behaves_like 'code without offense', <<-CODE
class Foo
private def bar
puts 'baz'
end
end
CODE
it_behaves_like 'code without offense', <<-CODE
class Foo
private
def bar; end
end
CODE
it_behaves_like 'code without offense', <<-CODE
class Foo
private def bar; end
end
CODE
context 'when required for non-public methods' do
let(:require_for_non_public_methods) { true }
it_behaves_like 'code with offense', <<-CODE
class Foo
private
def bar
puts 'baz'
end
end
CODE
it_behaves_like 'code with offense', <<-CODE
class Foo
private def bar
puts 'baz'
end
end
CODE
it_behaves_like 'code with offense', <<-CODE
class Foo
private
def bar; end
end
CODE
it_behaves_like 'code with offense', <<-CODE
class Foo
private def bar; end
end
CODE
end
end
end
context 'with documentation comment' do
context 'when method is public' do
it_behaves_like 'code without offense', <<-CODE
class Foo
# Documentation
def bar
puts 'baz'
end
end
CODE
it_behaves_like 'code without offense', <<-CODE
class Foo
# Documentation
def bar; end
end
CODE
end
end
context 'with annotation comment' do
it_behaves_like 'code with offense', <<-CODE
class Foo
# FIXME: offense
def bar
puts 'baz'
end
end
CODE
end
context 'with directive comment' do
it_behaves_like 'code with offense', <<-CODE
class Foo
# rubocop:disable Style/For
def bar
puts 'baz'
end
end
CODE
end
context 'with both public and private methods' do
it_behaves_like 'code with offense', <<-CODE
class Foo
def bar
puts 'baz'
end
private
def baz
puts 'baz'
end
end
CODE
it_behaves_like 'code without offense', <<-CODE
class Foo
# Documentation
def bar
puts 'baz'
end
private
def baz
puts 'baz'
end
end
CODE
context 'when required for non-public methods' do
let(:require_for_non_public_methods) { true }
it_behaves_like 'code with offense', <<-CODE
class Foo
# Documentation
def bar
puts 'baz'
end
private
def baz
puts 'baz'
end
end
CODE
end
end
end
context 'when declaring methods in a module' do
context 'without documentation comment' do
context 'wheh method is public' do
it_behaves_like 'code with offense', <<-CODE
module Foo
def bar
puts 'baz'
end
end
CODE
it_behaves_like 'code with offense', <<-CODE
module Foo
def method; end
end
CODE
end
context 'when method is private' do
it_behaves_like 'code without offense', <<-CODE
module Foo
private
def bar
puts 'baz'
end
end
CODE
it_behaves_like 'code without offense', <<-CODE
module Foo
private def bar
puts 'baz'
end
end
CODE
it_behaves_like 'code without offense', <<-CODE
module Foo
private
def bar; end
end
CODE
it_behaves_like 'code without offense', <<-CODE
module Foo
private def bar; end
end
CODE
context 'when required for non-public methods' do
let(:require_for_non_public_methods) { true }
it_behaves_like 'code with offense', <<-CODE
module Foo
private
def bar
puts 'baz'
end
end
CODE
it_behaves_like 'code with offense', <<-CODE
module Foo
private def bar
puts 'baz'
end
end
CODE
it_behaves_like 'code with offense', <<-CODE
module Foo
private
def bar; end
end
CODE
it_behaves_like 'code with offense', <<-CODE
module Foo
private def bar; end
end
CODE
end
end
end
context 'with documentation comment' do
context 'when method is public' do
it_behaves_like 'code without offense', <<-CODE
module Foo
# Documentation
def bar
puts 'baz'
end
end
CODE
it_behaves_like 'code without offense', <<-CODE
module Foo
# Documentation
def bar; end
end
CODE
end
end
context 'with both public and private methods' do
it_behaves_like 'code with offense', <<-CODE
module Foo
def bar
puts 'baz'
end
private
def baz
puts 'baz'
end
end
CODE
it_behaves_like 'code without offense', <<-CODE
module Foo
# Documentation
def bar
puts 'baz'
end
private
def baz
puts 'baz'
end
end
CODE
context 'when required for non-public methods' do
let(:require_for_non_public_methods) { true }
it_behaves_like 'code with offense', <<-CODE
module Foo
# Documentation
def bar
puts 'baz'
end
private
def baz
puts 'baz'
end
end
CODE
end
end
end
context 'when declaring methods for class instance' do
context 'without documentation comment' do
it_behaves_like 'code with offense', <<-CODE
class Foo; end
foo = Foo.new
def foo.bar
puts 'baz'
end
CODE
it_behaves_like 'code with offense', <<-CODE
class Foo; end
foo = Foo.new
def foo.bar; end
CODE
end
context 'with documentation comment' do
it_behaves_like 'code without offense', <<-CODE
class Foo; end
foo = Foo.new
# Documentation
def foo.bar
puts 'baz'
end
CODE
it_behaves_like 'code without offense', <<-CODE
class Foo; end
foo = Foo.new
# Documentation
def foo.bar; end
CODE
context 'when method is private' do
it_behaves_like 'code without offense', <<-CODE
class Foo; end
foo = Foo.bar
private
def foo.bar; end
CODE
it_behaves_like 'code without offense', <<-CODE
class Foo; end
foo = Foo.new
private
def foo.bar
puts 'baz'
end
CODE
it_behaves_like 'code without offense', <<-CODE
class Foo; end
foo = Foo.new
private def foo.bar; end
CODE
it_behaves_like 'code without offense', <<-CODE
class Foo; end
foo = Foo.new
private def foo.bar
puts 'baz'
end
CODE
context 'when required for non-public methods' do
let(:require_for_non_public_methods) { true }
it_behaves_like 'code with offense', <<-CODE
class Foo; end
foo = Foo.bar
private
def foo.bar; end
CODE
it_behaves_like 'code with offense', <<-CODE
class Foo; end
foo = Foo.new
private
def foo.bar
puts 'baz'
end
CODE
it_behaves_like 'code with offense', <<-CODE
class Foo; end
foo = Foo.new
private def foo.bar; end
CODE
it_behaves_like 'code with offense', <<-CODE
class Foo; end
foo = Foo.new
private def foo.bar
puts 'baz'
end
CODE
end
end
context 'with both public and private methods' do
it_behaves_like 'code with offense', <<-CODE
class Foo; end
foo = Foo.new
def foo.bar
puts 'baz'
end
private
def foo.baz
puts 'baz'
end
CODE
it_behaves_like 'code without offense', <<-CODE
class Foo; end
foo = Foo.new
# Documentation
def foo.bar
puts 'baz'
end
private
def foo.baz
puts 'baz'
end
CODE
context 'when required for non-public methods' do
let(:require_for_non_public_methods) { true }
it_behaves_like 'code with offense', <<-CODE
class Foo; end
foo = Foo.new
# Documentation
def foo.bar
puts 'baz'
end
private
def foo.baz
puts 'baz'
end
CODE
end
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/documentation_spec.rb 0000664 0000000 0000000 00000023205 13070542236 0025673 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::Documentation do
subject(:cop) { described_class.new(config) }
let(:config) do
RuboCop::Config.new('Style/CommentAnnotation' => {
'Keywords' => %w[TODO FIXME OPTIMIZE HACK REVIEW]
})
end
it 'registers an offense for non-empty class' do
inspect_source(cop,
['class My_Class',
' def method',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'does not consider comment followed by empty line to be class ' \
'documentation' do
inspect_source(cop,
['# Copyright 2014',
'# Some company',
'',
'class My_Class',
' def method',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for non-namespace' do
inspect_source(cop,
['module My_Class',
' def method',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for empty module without documentation' do
# Because why would you have an empty module? It requires some
# explanation.
inspect_source(cop,
['module Test',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'accepts non-empty class with documentation' do
inspect_source(cop,
['# class comment',
'class My_Class',
' def method',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for non-empty class with annotation comment' do
inspect_source(cop,
['# OPTIMIZE: Make this faster.',
'class My_Class',
' def method',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for non-empty class with directive comment' do
inspect_source(cop,
['# rubocop:disable Style/For',
'class My_Class',
' def method',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers offense for non-empty class with frozen string comment' do
inspect_source(cop,
['# frozen_string_literal: true',
'class My_Class',
' def method',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for non-empty class with encoding comment' do
inspect_source(cop,
['# encoding: ascii-8bit',
'class My_Class',
' def method',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'accepts non-empty class with annotation comment followed by other ' \
'comment' do
inspect_source(cop,
['# OPTIMIZE: Make this faster.',
'# Class comment.',
'class My_Class',
' def method',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts non-empty class with comment that ends with an annotation' do
inspect_source(cop,
['# Does fooing.',
'# FIXME: Not yet implemented.',
'class Foo',
' def initialize',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts non-empty module with documentation' do
inspect_source(cop,
['# class comment',
'module My_Class',
' def method',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts empty class without documentation' do
inspect_source(cop,
['class My_Class',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts namespace module without documentation' do
inspect_source(cop,
['module Test',
' class A; end',
' class B; end',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts namespace class without documentation' do
inspect_source(cop,
['class Test',
' class A; end',
' class B; end',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts namespace class which defines constants' do
inspect_source(cop,
['class Test',
' A = Class.new',
' B = Class.new(A)',
' C = Class.new { call_method }',
' D = 1',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts namespace module which defines constants' do
inspect_source(cop,
['module Test',
' A = Class.new',
' B = Class.new(A)',
' C = Class.new { call_method }',
' D = 1',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not raise an error for an implicit match conditional' do
expect do
inspect_source(cop,
['class Test',
' if //',
' end',
'end'])
end.not_to raise_error
end
it 'registers an offense if the comment line contains code' do
inspect_source(cop,
['module A # The A Module',
' class B',
' C = 1',
' def method',
' end',
' end',
'end'])
expect(cop.offenses.size).to eq 1
end
context 'sparse and trailing comments' do
%w[class module].each do |keyword|
it "ignores comments after #{keyword} node end" do
inspect_source(cop,
['module TestModule',
' # documentation comment',
" #{keyword} Test",
' def method',
' end',
' end # decorating comment',
'end'])
expect(cop.offenses).to be_empty
end
it "ignores sparse comments inside #{keyword} node" do
inspect_source(cop,
['module TestModule',
" #{keyword} Test",
' def method',
' end',
' # sparse comment',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
end
end
end
context 'with # :nodoc:' do
%w[class module].each do |keyword|
it "accepts non-namespace #{keyword} without documentation" do
inspect_source(cop,
["#{keyword} Test #:nodoc:",
' def method',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it "registers an offense for nested #{keyword} without documentation" do
inspect_source(cop,
['module TestModule #:nodoc:',
' TEST = 20',
" #{keyword} Test",
' def method',
' end',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
end
context 'with `all` modifier' do
it "accepts nested #{keyword} without documentation" do
inspect_source(cop,
['module A #:nodoc: all',
' module B',
' TEST = 20',
" #{keyword} Test",
' TEST = 20',
' end',
' end',
'end'])
expect(cop.offenses).to be_empty
end
end
end
context 'on a subclass' do
it 'accepts non-namespace subclass without documentation' do
inspect_source(cop,
['class Test < Parent #:nodoc:',
' def method',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for nested subclass without documentation' do
inspect_source(cop,
['module TestModule #:nodoc:',
' TEST = 20',
' class Test < Parent',
' def method',
' end',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
end
context 'with `all` modifier' do
it 'accepts nested subclass without documentation' do
inspect_source(cop,
['module A #:nodoc: all',
' module B',
' TEST = 20',
' class Test < Parent',
' TEST = 20',
' end',
' end',
'end'])
expect(cop.offenses).to be_empty
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/dot_position_spec.rb 0000664 0000000 0000000 00000012255 13070542236 0025537 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::DotPosition, :config do
subject(:cop) { described_class.new(config) }
context 'Leading dots style' do
let(:cop_config) { { 'EnforcedStyle' => 'leading' } }
it 'registers an offense for trailing dot in multi-line call' do
inspect_source(cop, ['something.',
' method_name'])
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['.'])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'trailing')
end
it 'registers an offense for correct + opposite' do
inspect_source(cop, ['something',
' .method_name',
'something.',
' method_name'])
expect(cop.offenses.size).to eq(1)
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'accepts leading do in multi-line method call' do
inspect_source(cop, ['something',
' .method_name'])
expect(cop.offenses).to be_empty
end
it 'does not err on method call with no dots' do
inspect_source(cop, 'puts something')
expect(cop.offenses).to be_empty
end
it 'does not err on method call without a method name' do
inspect_source(cop, ['l.',
'(1)'])
expect(cop.offenses.size).to eq(1)
end
it 'does not err on method call on same line' do
inspect_source(cop, 'something.method_name')
expect(cop.offenses).to be_empty
end
it 'auto-corrects trailing dot in multi-line call' do
new_source = autocorrect_source(cop, ['something.',
' method_name'])
expect(new_source).to eq(['something',
' .method_name'].join("\n"))
end
it 'auto-corrects trailing dot in multi-line call without selector' do
new_source = autocorrect_source(cop, ['something.',
' (1)'])
expect(new_source).to eq(['something',
' .(1)'].join("\n"))
end
it 'auto-corrects correct + opposite style' do
new_source = autocorrect_source(cop, ['something',
' .method_name',
'something.',
' method_name'])
expect(new_source).to eq(['something',
' .method_name',
'something',
' .method_name'].join("\n"))
end
context 'when there is an intervening line comment' do
it 'does not register offense' do
inspect_source(cop, ['something.',
'# a comment here',
' method_name'])
expect(cop.offenses).to be_empty
end
end
context 'when there is an intervening blank line' do
it 'does not register offense' do
inspect_source(cop, ['something.',
'',
' method_name'])
expect(cop.offenses).to be_empty
end
end
end
context 'Trailing dots style' do
let(:cop_config) { { 'EnforcedStyle' => 'trailing' } }
it 'registers an offense for leading dot in multi-line call' do
inspect_source(cop, ['something',
' .method_name'])
expect(cop.messages)
.to eq(['Place the . on the previous line, together with the method ' \
'call receiver.'])
expect(cop.highlights).to eq(['.'])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'leading')
end
it 'accepts trailing dot in multi-line method call' do
inspect_source(cop, ['something.',
' method_name'])
expect(cop.offenses).to be_empty
end
it 'does not err on method call with no dots' do
inspect_source(cop, 'puts something')
expect(cop.offenses).to be_empty
end
it 'does not err on method call without a method name' do
inspect_source(cop, ['l',
'.(1)'])
expect(cop.offenses.size).to eq(1)
end
it 'does not err on method call on same line' do
inspect_source(cop, 'something.method_name')
expect(cop.offenses).to be_empty
end
it 'does not get confused by several lines of chained methods' do
inspect_source(cop, ['File.new(something).',
'readlines.map.',
'compact.join("\n")'])
expect(cop.offenses).to be_empty
end
it 'auto-corrects leading dot in multi-line call' do
new_source = autocorrect_source(cop, ['something',
' .method_name'])
expect(new_source).to eq(['something.',
' method_name'].join("\n"))
end
it 'auto-corrects leading dot in multi-line call without selector' do
new_source = autocorrect_source(cop, ['something',
' .(1)'])
expect(new_source).to eq(['something.',
' (1)'].join("\n"))
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/double_negation_spec.rb 0000664 0000000 0000000 00000001020 13070542236 0026147 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::DoubleNegation do
subject(:cop) { described_class.new }
it 'registers an offense for !!' do
inspect_source(cop, '!!test.something')
expect(cop.offenses.size).to eq(1)
end
it 'does not register an offense for !' do
inspect_source(cop, '!test.something')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for not not' do
inspect_source(cop, 'not not test.something')
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/each_for_simple_loop_spec.rb 0000664 0000000 0000000 00000007641 13070542236 0027200 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::EachForSimpleLoop do
subject(:cop) { described_class.new }
OFFENSE_MSG = 'Use `Integer#times` for a simple loop ' \
'which iterates a fixed number of times.'.freeze
it 'registers offense for inclusive end range' do
inspect_source(cop, '(0..10).each {}')
expect(cop.offenses.size).to eq 1
expect(cop.messages).to eq([OFFENSE_MSG])
expect(cop.highlights).to eq(['(0..10).each'])
end
it 'registers offense for exclusive end range' do
inspect_source(cop, '(0...10).each {}')
expect(cop.offenses.size).to eq 1
expect(cop.messages).to eq([OFFENSE_MSG])
expect(cop.highlights).to eq(['(0...10).each'])
end
it 'registers offense for exclusive end range with do ... end syntax' do
inspect_source(cop, ['(0...10).each do',
'end'])
expect(cop.offenses.size).to eq 1
expect(cop.messages).to eq([OFFENSE_MSG])
expect(cop.highlights).to eq(['(0...10).each'])
end
it 'registers an offense for range not starting with zero' do
inspect_source(cop, ['(3..7).each do',
'end'])
expect(cop.offenses.size).to eq 1
expect(cop.messages).to eq([OFFENSE_MSG])
expect(cop.highlights).to eq(['(3..7).each'])
end
it 'does not register offense if range startpoint is not constant' do
inspect_source(cop, '(a..10).each {}')
expect(cop.offenses).to be_empty
end
it 'does not register offense if range endpoint is not constant' do
inspect_source(cop, '(0..b).each {}')
expect(cop.offenses).to be_empty
end
it 'does not register offense for inline block with parameters' do
inspect_source(cop, '(0..10).each { |n| puts n }')
expect(cop.offenses).to be_empty
end
it 'does not register offense for multiline block with parameters' do
inspect_source(cop, ['(0..10).each do |n|',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register offense for character range' do
inspect_source(cop, "('a'..'b').each {}")
expect(cop.offenses).to be_empty
end
context 'when using an inclusive range' do
it 'autocorrects the source with inline block' do
corrected = autocorrect_source(cop, '(0..10).each {}')
expect(corrected).to eq '11.times {}'
end
it 'autocorrects the source with multiline block' do
corrected = autocorrect_source(cop, ['(0..10).each do',
'end'])
expect(corrected).to eq "11.times do\nend"
end
it 'autocorrects the range not starting with zero' do
corrected = autocorrect_source(cop, ['(3..7).each do',
'end'])
expect(corrected).to eq "5.times do\nend"
end
it 'does not autocorrect range not starting with zero and using param' do
corrected = autocorrect_source(cop, ['(3..7).each do |n|',
'end'])
expect(corrected).to eq "(3..7).each do |n|\nend"
end
end
context 'when using an exclusive range' do
it 'autocorrects the source with inline block' do
corrected = autocorrect_source(cop, '(0...10).each {}')
expect(corrected).to eq '10.times {}'
end
it 'autocorrects the source with multiline block' do
corrected = autocorrect_source(cop, ['(0...10).each do',
'end'])
expect(corrected).to eq "10.times do\nend"
end
it 'autocorrects the range not starting with zero' do
corrected = autocorrect_source(cop, ['(3...7).each do',
'end'])
expect(corrected).to eq "4.times do\nend"
end
it 'does not autocorrect range not starting with zero and using param' do
corrected = autocorrect_source(cop, ['(3...7).each do |n|',
'end'])
expect(corrected).to eq "(3...7).each do |n|\nend"
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/each_with_object_spec.rb 0000664 0000000 0000000 00000007140 13070542236 0026303 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::EachWithObject do
subject(:cop) { described_class.new }
it 'finds inject and reduce with passed in and returned hash' do
inspect_source(cop,
['[].inject({}) { |a, e| a }',
'',
'[].reduce({}) do |a, e|',
' a[e] = 1',
' a[e] = 1',
' a',
'end'])
expect(cop.offenses.size).to eq(2)
expect(cop.offenses.map(&:line).sort).to eq([1, 3])
expect(cop.messages)
.to eq(['Use `each_with_object` instead of `inject`.',
'Use `each_with_object` instead of `reduce`.'])
expect(cop.highlights).to eq(%w[inject reduce])
end
it 'correctly autocorrects' do
corrected = autocorrect_source(cop, ['[1, 2, 3].inject({}) do |h, i|',
' h[i] = i',
' h',
'end'])
expect(corrected).to eq(['[1, 2, 3].each_with_object({}) do |i, h|',
' h[i] = i',
' ',
'end'].join("\n"))
end
it 'correctly autocorrects with return value only' do
corrected = autocorrect_source(cop, ['[1, 2, 3].inject({}) do |h, i|',
' h',
'end'])
expect(corrected).to eq(['[1, 2, 3].each_with_object({}) do |i, h|',
' ',
'end'].join("\n"))
end
it 'ignores inject and reduce with passed in, but not returned hash' do
inspect_source(cop,
['[].inject({}) do |a, e|',
' a + e',
'end',
'',
'[].reduce({}) do |a, e|',
' my_method e, a',
'end'])
expect(cop.offenses).to be_empty
end
it 'ignores inject and reduce with empty body' do
inspect_source(cop,
['[].inject({}) do |a, e|',
'end',
'',
'[].reduce({}) { |a, e| }'])
expect(cop.offenses).to be_empty
end
it 'ignores inject and reduce with condition as body' do
inspect_source(cop,
['[].inject({}) do |a, e|',
' a = e if e',
'end',
'',
'[].inject({}) do |a, e|',
' if e',
' a = e',
' end',
'end',
'',
'[].reduce({}) do |a, e|',
' a = e ? e : 2',
'end'])
expect(cop.offenses).to be_empty
end
it 'ignores inject and reduce passed in symbol' do
inspect_source(cop, '[].inject(:+)', '[].reduce(:+)')
expect(cop.offenses).to be_empty
end
it 'does not blow up for reduce with no arguments' do
inspect_source(cop, '[1, 2, 3].inject { |a, e| a + e }')
expect(cop.offenses).to be_empty
end
it 'ignores inject/reduce with assignment to accumulator param in block' do
inspect_source(cop, ['r = [1, 2, 3].reduce({}) do |memo, item|',
' memo += item > 2 ? item : 0',
' memo',
'end'])
expect(cop.offenses).to be_empty
end
context 'when a simple literal is passed as initial value' do
it 'ignores inject/reduce' do
inspect_source(cop, 'array.reduce(0) { |a, e| a }')
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/else_alignment_spec.rb 0000664 0000000 0000000 00000043267 13070542236 0026022 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::ElseAlignment do
subject(:cop) { described_class.new(config) }
let(:config) do
RuboCop::Config.new('Lint/EndAlignment' => end_alignment_config)
end
let(:end_alignment_config) do
{ 'Enabled' => true, 'EnforcedStyleAlignWith' => 'variable' }
end
it 'accepts a ternary if' do
inspect_source(cop, 'cond ? func1 : func2')
expect(cop.offenses).to be_empty
end
context 'with if statement' do
it 'registers an offense for misaligned else' do
inspect_source(cop,
['if cond',
' func1',
' else',
' func2',
'end'])
expect(cop.messages).to eq(['Align `else` with `if`.'])
expect(cop.highlights).to eq(['else'])
end
it 'registers an offense for misaligned elsif' do
inspect_source(cop,
[' if a1',
' b1',
'elsif a2',
' b2',
' end'])
expect(cop.messages).to eq(['Align `elsif` with `if`.'])
expect(cop.highlights).to eq(['elsif'])
end
it 'accepts indentation after else when if is on new line after ' \
'assignment' do
inspect_source(cop,
['Rails.application.config.ideal_postcodes_key =',
' if Rails.env.production? || Rails.env.staging?',
' "AAAA-AAAA-AAAA-AAAA"',
' else',
' "BBBB-BBBB-BBBB-BBBB"',
' end'])
expect(cop.offenses).to be_empty
end
describe '#autocorrect' do
it 'corrects bad alignment' do
corrected = autocorrect_source(cop,
[' if a1',
' b1',
' elsif a2',
' b2',
'else',
' c',
' end'])
expect(cop.messages).to eq(['Align `elsif` with `if`.',
'Align `else` with `if`.'])
expect(corrected)
.to eq [' if a1',
' b1',
' elsif a2',
' b2',
' else',
' c',
' end'].join("\n")
end
end
it 'accepts a one line if statement' do
inspect_source(cop, 'if cond then func1 else func2 end')
expect(cop.offenses).to be_empty
end
it 'accepts a correctly aligned if/elsif/else/end' do
inspect_source(cop,
['if a1',
' b1',
'elsif a2',
' b2',
'else',
' c',
'end'])
expect(cop.offenses).to be_empty
end
context 'for a file with byte order mark' do
let(:bom) { "\xef\xbb\xbf" }
it 'accepts a correctly aligned if/elsif/else/end' do
inspect_source(cop,
["#{bom}if a1",
' b1',
'elsif a2',
' b2',
'else',
' c',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with assignment' do
context 'when alignment style is variable' do
context 'and end is aligned with variable' do
it 'accepts an if-else with end aligned with setter' do
inspect_source(cop,
['foo.bar = if baz',
' derp1',
'else',
' derp2',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts an if-elsif-else with end aligned with setter' do
inspect_source(cop,
['foo.bar = if baz',
' derp1',
'elsif meh',
' derp2',
'else',
' derp3',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts an if with end aligned with element assignment' do
inspect_source(cop,
['foo[bar] = if baz',
' derp',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts an if/else' do
inspect_source(cop,
['var = if a',
' 0',
'else',
' 1',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts an if/else with chaining after the end' do
inspect_source(cop,
['var = if a',
' 0',
'else',
' 1',
'end.abc.join("")'])
expect(cop.offenses).to be_empty
end
it 'accepts an if/else with chaining with a block after the end' do
inspect_source(cop,
['var = if a',
' 0',
'else',
' 1',
'end.abc.tap {}'])
expect(cop.offenses).to be_empty
end
end
context 'and end is aligned with keyword' do
it 'registers offenses for an if with setter' do
inspect_source(cop,
['foo.bar = if baz',
' derp1',
' elsif meh',
' derp2',
' else',
' derp3',
' end'])
expect(cop.messages).to eq(['Align `elsif` with `foo.bar`.',
'Align `else` with `foo.bar`.'])
end
it 'registers an offense for an if with element assignment' do
inspect_source(cop,
['foo[bar] = if baz',
' derp1',
' else',
' derp2',
' end'])
expect(cop.messages).to eq(['Align `else` with `foo[bar]`.'])
end
it 'registers an offense for an if' do
inspect_source(cop,
['var = if a',
' 0',
' else',
' 1',
' end'])
expect(cop.messages).to eq(['Align `else` with `var`.'])
end
end
end
shared_examples 'assignment and if with keyword alignment' do
context 'and end is aligned with variable' do
it 'registers an offense for an if' do
inspect_source(cop,
['var = if a',
' 0',
'elsif b',
' 1',
'end'])
expect(cop.messages).to eq(['Align `elsif` with `if`.'])
end
it 'autocorrects bad alignment' do
corrected = autocorrect_source(cop,
['var = if a',
' b1',
'else',
' b2',
'end'])
expect(corrected).to eq ['var = if a',
' b1',
' else',
' b2',
'end'].join("\n")
end
end
context 'and end is aligned with keyword' do
it 'accepts an if in assignment' do
inspect_source(cop,
['var = if a',
' 0',
' end'])
expect(cop.offenses).to be_empty
end
it 'accepts an if/else in assignment' do
inspect_source(cop,
['var = if a',
' 0',
' else',
' 1',
' end'])
expect(cop.offenses).to be_empty
end
it 'accepts an if/else in assignment on next line' do
inspect_source(cop,
['var =',
' if a',
' 0',
' else',
' 1',
' end'])
expect(cop.offenses).to be_empty
end
it 'accepts a while in assignment' do
inspect_source(cop,
['var = while a',
' b',
' end'])
expect(cop.offenses).to be_empty
end
it 'accepts an until in assignment' do
inspect_source(cop,
['var = until a',
' b',
' end'])
expect(cop.offenses).to be_empty
end
end
end
context 'when alignment style is keyword by choice' do
let(:end_alignment_config) do
{ 'Enabled' => true, 'EnforcedStyleAlignWith' => 'keyword' }
end
include_examples 'assignment and if with keyword alignment'
end
end
it 'accepts an if/else branches with rescue clauses' do
# Because of how the rescue clauses come out of Parser, these are
# special and need to be tested.
inspect_source(cop,
['if a',
' a rescue nil',
'else',
' a rescue nil',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with unless' do
it 'registers an offense for misaligned else' do
inspect_source(cop,
['unless cond',
' func1',
' else',
' func2',
'end'])
expect(cop.messages).to eq(['Align `else` with `unless`.'])
end
it 'accepts a correctly aligned else in an otherwise empty unless' do
inspect_source(cop,
['unless a',
'else',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts an empty unless' do
inspect_source(cop,
['unless a',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with case' do
it 'registers an offense for misaligned else' do
inspect_source(cop,
['case a',
'when b',
' c',
'when d',
' e',
' else',
' f',
'end'])
expect(cop.messages).to eq(['Align `else` with `when`.'])
end
it 'accepts correctly aligned case/when/else' do
inspect_source(cop,
['case a',
'when b',
' c',
' c',
'when d',
'else',
' f',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts case without else' do
inspect_source(cop,
['case superclass',
'when /\A(#{NAMESPACEMATCH})(?:\s|\Z)/',
' $1',
'when "self"',
' namespace.path',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts else aligned with when but not with case' do
# "Indent when as deep as case" is the job of another cop, and this is
# one of the possible styles supported by configuration.
inspect_source(cop,
['case code_type',
" when 'ruby', 'sql', 'plain'",
' code_type',
" when 'erb'",
" 'ruby; html-script: true'",
' when "html"',
" 'xml'",
' else',
" 'plain'",
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with def/defs' do
it 'accepts an empty def body' do
inspect_source(cop,
['def test',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts an empty defs body' do
inspect_source(cop,
['def self.test',
'end'])
expect(cop.offenses).to be_empty
end
if RUBY_VERSION >= '2.1'
context 'when modifier and def are on the same line' do
it 'accepts a correctly aligned body' do
inspect_source(cop,
['private def test',
' something',
'rescue',
' handling',
'else',
' something_else',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for else not aligned with private' do
inspect_source(cop,
['private def test',
' something',
' rescue',
' handling',
' else',
' something_else',
' end'])
expect(cop.messages).to eq(['Align `else` with `private`.'])
end
end
end
end
context 'with begin/rescue/else/ensure/end' do
it 'registers an offense for misaligned else' do
inspect_source(cop,
['def my_func',
" puts 'do something outside block'",
' begin',
" puts 'do something error prone'",
' rescue SomeException, SomeOther => e',
" puts 'wrongly intended error handling'",
' rescue',
" puts 'wrongly intended error handling'",
'else',
" puts 'wrongly intended normal case handling'",
' ensure',
" puts 'wrongly intended common handling'",
' end',
'end'])
expect(cop.messages).to eq(['Align `else` with `begin`.'])
end
it 'accepts a correctly aligned else' do
inspect_source(cop,
['begin',
" raise StandardError.new('Fail') if rand(2).odd?",
'rescue StandardError => error',
' $stderr.puts error.message',
'else',
" $stdout.puts 'Lucky you!'",
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with def/rescue/else/ensure/end' do
it 'accepts a correctly aligned else' do
inspect_source(cop,
['def my_func(string)',
' puts string',
'rescue => e',
' puts e',
'else',
' puts e',
'ensure',
" puts 'I love methods that print'",
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for misaligned else' do
inspect_source(cop,
['def my_func(string)',
' puts string',
'rescue => e',
' puts e',
' else',
' puts e',
'ensure',
" puts 'I love methods that print'",
'end'])
expect(cop.messages).to eq(['Align `else` with `def`.'])
end
end
context 'with def/rescue/else/end' do
it 'accepts a correctly aligned else' do
inspect_source(cop,
['def my_func',
" puts 'do something error prone'",
'rescue SomeException',
" puts 'error handling'",
'rescue',
" puts 'error handling'",
'else',
" puts 'normal handling'",
'end'])
expect(cop.messages).to be_empty
end
it 'registers an offense for misaligned else' do
inspect_source(cop,
['def my_func',
" puts 'do something error prone'",
'rescue SomeException',
" puts 'error handling'",
'rescue',
" puts 'error handling'",
' else',
" puts 'normal handling'",
'end'])
expect(cop.messages).to eq(['Align `else` with `def`.'])
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/empty_case_condition_spec.rb 0000664 0000000 0000000 00000006570 13070542236 0027227 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::EmptyCaseCondition do
subject(:cop) { described_class.new }
shared_examples 'detect/correct empty case, accept non-empty case' do
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq [described_class::MSG]
end
it 'correctly autocorrects' do
expect(autocorrect_source(cop, source)).to eq corrected_source.join("\n")
end
let(:source_with_case) { source.map { |s| s.gsub(/case/, 'case :a') } }
it 'accepts the source with case' do
inspect_source(cop, source_with_case)
expect(cop.messages).to be_empty
end
end
context 'given a case statement with an empty case' do
context 'with multiple when branches and an else' do
let(:source) do
['case',
'when 1 == 2',
' foo',
'when 1 == 1',
' bar',
'else',
' baz',
'end']
end
let(:corrected_source) do
['if 1 == 2',
' foo',
'elsif 1 == 1',
' bar',
'else',
' baz',
'end']
end
it_behaves_like 'detect/correct empty case, accept non-empty case'
end
context 'with multiple when branches and no else' do
let(:source) do
['case',
'when 1 == 2',
' foo',
'when 1 == 1',
' bar',
'end']
end
let(:corrected_source) do
['if 1 == 2',
' foo',
'elsif 1 == 1',
' bar',
'end']
end
it_behaves_like 'detect/correct empty case, accept non-empty case'
end
context 'with a single when branch and an else' do
let(:source) do
['case',
'when 1 == 2',
' foo',
'else',
' bar',
'end']
end
let(:corrected_source) do
['if 1 == 2',
' foo',
'else',
' bar',
'end']
end
it_behaves_like 'detect/correct empty case, accept non-empty case'
end
context 'with a single when branch and no else' do
let(:source) do
['case',
'when 1 == 2',
' foo',
'end']
end
let(:corrected_source) do
['if 1 == 2',
' foo',
'end']
end
it_behaves_like 'detect/correct empty case, accept non-empty case'
end
context 'with a when branch including comma-delimited alternatives' do
let(:source) do
['case',
'when false',
' foo',
'when nil, false, 1',
' bar',
'when false, 1',
' baz',
'end']
end
let(:corrected_source) do
['if false',
' foo',
'elsif nil || false || 1',
' bar',
'elsif false || 1',
' baz',
'end']
end
it_behaves_like 'detect/correct empty case, accept non-empty case'
end
context 'with when branches using then' do
let(:source) do
['case',
'when false then foo',
'when nil, false, 1 then bar',
'when false, 1 then baz',
'end']
end
let(:corrected_source) do
['if false then foo',
'elsif nil || false || 1 then bar',
'elsif false || 1 then baz',
'end']
end
it_behaves_like 'detect/correct empty case, accept non-empty case'
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/empty_else_spec.rb 0000664 0000000 0000000 00000035263 13070542236 0025177 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::EmptyElse do
subject(:cop) { described_class.new(config) }
let(:missing_else_config) { {} }
shared_examples 'auto-correct' do |keyword|
context 'MissingElse is disabled' do
it 'does auto-correction' do
expect(autocorrect_source(cop, source)).to eq(corrected_source)
end
end
%w[both if case].each do |missing_else_style|
context "MissingElse is #{missing_else_style}" do
let(:missing_else_config) do
{ 'Enabled' => true,
'EnforcedStyle' => missing_else_style }
end
if ['both', keyword].include? missing_else_style
it 'does not auto-correct' do
expect(autocorrect_source(cop, source)).to eq(source)
expect(cop.offenses.map(&:corrected?)).to eq [false]
end
else
it 'does auto-correction' do
expect(autocorrect_source(cop, source)).to eq(corrected_source)
end
end
end
end
end
shared_examples_for 'offense registration' do
it 'registers an offense with correct message' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Redundant `else`-clause.'])
end
it 'registers an offense with correct location' do
inspect_source(cop, source)
expect(cop.highlights).to eq(['else'])
end
end
context 'configured to warn on empty else' do
let(:config) do
RuboCop::Config.new('Style/EmptyElse' => {
'EnforcedStyle' => 'empty',
'SupportedStyles' => %w[empty nil both]
},
'Style/MissingElse' => missing_else_config)
end
context 'given an if-statement' do
context 'with a completely empty else-clause' do
context 'using semicolons' do
let(:source) { 'if a; foo else end' }
let(:corrected_source) { 'if a; foo end' }
it_behaves_like 'offense registration'
it_behaves_like 'auto-correct', 'if'
end
context 'not using semicolons' do
let(:source) do
['if a',
' foo',
'else',
'end'].join("\n")
end
let(:corrected_source) do
['if a',
' foo',
'end'].join("\n")
end
it_behaves_like 'offense registration'
it_behaves_like 'auto-correct', 'if'
end
end
context 'with an else-clause containing only the literal nil' do
it "doesn't register an offense" do
inspect_source(cop, 'if a; foo elsif b; bar else nil end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'if cond; foo else bar; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'if cond; foo end')
expect(cop.messages).to be_empty
end
end
end
context 'given an unless-statement' do
context 'with a completely empty else-clause' do
let(:source) { 'unless cond; foo else end' }
let(:corrected_source) { 'unless cond; foo end' }
it_behaves_like 'offense registration'
it_behaves_like 'auto-correct', 'if'
end
context 'with an else-clause containing only the literal nil' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo else nil end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo else bar; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo end')
expect(cop.messages).to be_empty
end
end
end
context 'given a case statement' do
context 'with a completely empty else-clause' do
let(:source) { 'case v; when a; foo else end' }
let(:corrected_source) { 'case v; when a; foo end' }
it_behaves_like 'offense registration'
it_behaves_like 'auto-correct', 'case'
end
context 'with an else-clause containing only the literal nil' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo; when b; bar; else nil end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo; else b; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo; when b; bar; end')
expect(cop.messages).to be_empty
end
end
end
end
context 'configured to warn on nil in else' do
let(:config) do
RuboCop::Config.new('Style/EmptyElse' => {
'EnforcedStyle' => 'nil',
'SupportedStyles' => %w[empty nil both]
},
'Style/MissingElse' => missing_else_config)
end
context 'given an if-statement' do
context 'with a completely empty else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'if a; foo else end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause containing only the literal nil' do
context 'when standalone' do
let(:source) do
['if a',
' foo',
'elsif b',
' bar',
'else',
' nil',
'end'].join("\n")
end
let(:corrected_source) do
['if a',
' foo',
'elsif b',
' bar',
'end'].join("\n")
end
it_behaves_like 'offense registration'
it_behaves_like 'auto-correct', 'if'
end
context 'when the result is assigned to a variable' do
let(:source) do
['foobar = if a',
' foo',
' elsif b',
' bar',
' else',
' nil',
' end'].join("\n")
end
let(:corrected_source) do
['foobar = if a',
' foo',
' elsif b',
' bar',
' end'].join("\n")
end
it_behaves_like 'offense registration'
it_behaves_like 'auto-correct', 'if'
end
end
context 'with an else-clause containing only the literal nil ' \
'using semicolons' do
context 'with one elsif' do
let(:source) { 'if a; foo elsif b; bar else nil end' }
let(:corrected_source) { 'if a; foo elsif b; bar end' }
it_behaves_like 'offense registration'
it_behaves_like 'auto-correct', 'if'
end
context 'with multiple elsifs' do
let(:source) { 'if a; foo elsif b; bar; elsif c; bar else nil end' }
let(:corrected_source) { 'if a; foo elsif b; bar; elsif c; bar end' }
it_behaves_like 'offense registration'
it_behaves_like 'auto-correct', 'if'
end
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'if cond; foo else bar; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'if cond; foo end')
expect(cop.messages).to be_empty
end
end
end
context 'given an unless-statement' do
context 'with a completely empty else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo else end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause containing only the literal nil' do
let(:source) { 'unless cond; foo else nil end' }
let(:corrected_source) { 'unless cond; foo end' }
it_behaves_like 'offense registration'
it_behaves_like 'auto-correct', 'if'
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo else bar; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo end')
expect(cop.messages).to be_empty
end
end
end
context 'given a case statement' do
context 'with a completely empty else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo else end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause containing only the literal nil' do
context 'using semicolons' do
let(:source) { 'case v; when a; foo; when b; bar; else nil end' }
let(:corrected_source) { 'case v; when a; foo; when b; bar; end' }
it_behaves_like 'offense registration'
it_behaves_like 'auto-correct', 'case'
end
context 'when the result is assigned to a variable' do
let(:source) do
['foobar = case v',
' when a',
' foo',
' when b',
' bar',
' else',
' nil',
' end'].join("\n")
end
let(:corrected_source) do
['foobar = case v',
' when a',
' foo',
' when b',
' bar',
' end'].join("\n")
end
it_behaves_like 'offense registration'
it_behaves_like 'auto-correct', 'case'
end
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo; else b; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo; when b; bar; end')
expect(cop.messages).to be_empty
end
end
end
end
context 'configured to warn on empty else and nil in else' do
let(:config) do
RuboCop::Config.new('Style/EmptyElse' => {
'EnforcedStyle' => 'both',
'SupportedStyles' => %w[empty nil both]
},
'Style/MissingElse' => missing_else_config)
end
context 'given an if-statement' do
context 'with a completely empty else-clause' do
let(:source) { 'if a; foo else end' }
let(:corrected_source) { 'if a; foo end' }
it_behaves_like 'offense registration'
it_behaves_like 'auto-correct', 'if'
end
context 'with an else-clause containing only the literal nil' do
context 'with one elsif' do
let(:source) { 'if a; foo elsif b; bar else nil end' }
let(:corrected_source) { 'if a; foo elsif b; bar end' }
it_behaves_like 'offense registration'
it_behaves_like 'auto-correct', 'if'
end
context 'with multiple elsifs' do
let(:source) { 'if a; foo elsif b; bar; elsif c; bar else nil end' }
let(:corrected_source) { 'if a; foo elsif b; bar; elsif c; bar end' }
it_behaves_like 'offense registration'
it_behaves_like 'auto-correct', 'if'
end
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'if cond; foo else bar; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'if cond; foo end')
expect(cop.messages).to be_empty
end
end
end
context 'given an unless-statement' do
context 'with a completely empty else-clause' do
let(:source) { 'unless cond; foo else end' }
let(:corrected_source) { 'unless cond; foo end' }
it_behaves_like 'offense registration'
it_behaves_like 'auto-correct', 'if'
end
context 'with an else-clause containing only the literal nil' do
let(:source) { 'unless cond; foo else nil end' }
let(:corrected_source) { 'unless cond; foo end' }
it_behaves_like 'offense registration'
it_behaves_like 'auto-correct', 'if'
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo else bar; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo end')
expect(cop.messages).to be_empty
end
end
end
context 'given a case statement' do
context 'with a completely empty else-clause' do
let(:source) { 'case v; when a; foo else end' }
let(:corrected_source) { 'case v; when a; foo end' }
it_behaves_like 'offense registration'
it_behaves_like 'auto-correct', 'case'
end
context 'with an else-clause containing only the literal nil' do
let(:source) { 'case v; when a; foo; when b; bar; else nil end' }
let(:corrected_source) { 'case v; when a; foo; when b; bar; end' }
it_behaves_like 'offense registration'
it_behaves_like 'auto-correct', 'case'
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo; else b; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo; when b; bar; end')
expect(cop.messages).to be_empty
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/empty_line_after_magic_comment_spec.rb 0000664 0000000 0000000 00000005677 13070542236 0031247 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::EmptyLineAfterMagicComment do
let(:config) { RuboCop::Config.new }
subject(:cop) { described_class.new(config) }
it 'registers an offense for code that immediately follows comment' do
inspect_source(cop, ['# frozen_string_literal: true',
'class Foo; end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Add an empty line after magic comments.'])
end
it 'registers an offense for documentation immediately following comment' do
inspect_source(cop, ['# frozen_string_literal: true',
'# Documentation for Foo',
'class Foo; end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Add an empty line after magic comments.'])
end
it 'registers an offense when multiple magic comments without empty line' do
inspect_source(cop, ['# encoding: utf-8',
'# frozen_string_literal: true',
'class Foo; end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Add an empty line after magic comments.'])
end
it 'accepts code that separates the comment from the code with a newline' do
inspect_source(cop, ['# frozen_string_literal: true',
'',
'class Foo; end'])
expect(cop.offenses).to be_empty
end
it 'accepts an empty source file' do
inspect_source(cop, '')
expect(cop.offenses).to be_empty
end
it 'accepts a source file with only a magic comment' do
inspect_source(cop, '# frozen_string_literal: true')
expect(cop.offenses).to be_empty
end
it 'autocorrects by adding a newline' do
new_source = autocorrect_source(cop, ['# frozen_string_literal: true',
'class Foo; end'])
expect(new_source).to eq(["# frozen_string_literal: true\n",
'class Foo; end'].join("\n"))
end
it 'autocorrects by adding a newline above the documentation' do
new_source = autocorrect_source(cop, ['# frozen_string_literal: true',
'# Documentation for Foo',
'class Foo; end'])
expect(new_source).to eq(['# frozen_string_literal: true',
'',
'# Documentation for Foo',
'class Foo; end'].join("\n"))
end
it 'autocorrects by adding a newline above the documentation' do
new_source = autocorrect_source(cop, ['# frozen_string_literal: true',
'# Documentation for Foo',
'class Foo; end'])
expect(new_source).to eq(['# frozen_string_literal: true',
'',
'# Documentation for Foo',
'class Foo; end'].join("\n"))
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/empty_line_between_defs_spec.rb 0000664 0000000 0000000 00000026744 13070542236 0027714 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::EmptyLineBetweenDefs, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'AllowAdjacentOneLineDefs' => false } }
it 'finds offenses in inner classes' do
source = ['class K',
' def m',
' end',
' class J',
' def n',
' end',
' def o',
' end',
' end',
' # checks something',
' def p',
' end',
'end']
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.map(&:line).sort).to eq([7])
end
context 'when there are only comments between defs' do
let(:source) do
['class J',
' def n',
' end # n-related',
' # checks something o-related',
' # and more',
' def o',
' end',
'end']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'auto-corrects' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq(['class J',
' def n',
' end # n-related',
'',
' # checks something o-related',
' # and more',
' def o',
' end',
'end'].join("\n"))
end
end
context 'conditional method definitions' do
it 'accepts defs inside a conditional without blank lines in between' do
source = ['if condition',
' def foo',
' true',
' end',
'else',
' def foo',
' false',
' end',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'registers an offense for consecutive defs inside a conditional' do
source = ['if condition',
' def foo',
' true',
' end',
' def bar',
' true',
' end',
'else',
' def foo',
' false',
' end',
'end']
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
end
context 'class methods' do
context 'adjacent class methods' do
let(:offending_source) do
['class Test',
' def self.foo',
' true',
' end',
' def self.bar',
' true',
' end',
'end']
end
it 'registers an offense for missing blank line between methods' do
inspect_source(cop, offending_source)
expect(cop.offenses.size).to eq(1)
end
it 'autocorrects it' do
corrected = autocorrect_source(cop, offending_source)
expect(corrected).to eq(['class Test',
' def self.foo',
' true',
' end',
'',
' def self.bar',
' true',
' end',
'end']
.join("\n"))
end
end
context 'mixed instance and class methods' do
let(:offending_source) do
['class Test',
' def foo',
' true',
' end',
' def self.bar',
' true',
' end',
'end']
end
it 'registers an offense for missing blank line between methods' do
inspect_source(cop, offending_source)
expect(cop.offenses.size).to eq(1)
end
it 'autocorrects it' do
corrected = autocorrect_source(cop, offending_source)
expect(corrected).to eq(['class Test',
' def foo',
' true',
' end',
'',
' def self.bar',
' true',
' end',
'end']
.join("\n"))
end
end
end
# Only one def, so rule about empty line *between* defs does not
# apply.
it 'accepts a def that follows a line with code' do
source = ['x = 0',
'def m',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
# Only one def, so rule about empty line *between* defs does not
# apply.
it 'accepts a def that follows code and a comment' do
source = ['x = 0',
'# 123',
'def m',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'accepts the first def without leading empty line in a class' do
source = ['class K',
' def m',
' end',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'accepts a def that follows an empty line and then a comment' do
source = ['class A',
' # calculates value',
' def m',
' end',
'',
' private',
' # calculates size',
' def n',
' end',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'accepts a def that is the first of a module' do
source = ['module Util',
' public',
' #',
' def html_escape(s)',
' end',
'end']
inspect_source(cop, source)
expect(cop.messages).to be_empty
end
it 'accepts a nested def' do
source = ['def mock_model(*attributes)',
' Class.new do',
' def initialize(attrs)',
' end',
' end',
'end']
inspect_source(cop, source)
expect(cop.messages).to be_empty
end
it 'registers an offense for adjacent one-liners by default' do
source = ['def a; end',
'def b; end']
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'auto-corrects adjacent one-liners by default' do
corrected = autocorrect_source(cop, ['def a; end',
'def b; end'])
expect(corrected).to eq(['def a; end',
'',
'def b; end'].join("\n"))
end
it 'auto-corrects when there are too many new lines' do
corrected = autocorrect_source(cop, ['def a; end',
'',
'',
'',
'def b; end'])
expect(corrected).to eq(['def a; end',
'',
'def b; end'].join("\n"))
end
it 'treats lines with whitespaces as blank' do
source = ['class J',
' def n',
' end',
' ',
' def o',
' end',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it "doesn't allow more than the required number of newlines" do
source = ['class A',
' def n',
' end',
'',
'',
' def o',
' end',
'end']
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
context 'when AllowAdjacentOneLineDefs is enabled' do
let(:cop_config) { { 'AllowAdjacentOneLineDefs' => true } }
it 'accepts adjacent one-liners' do
source = ['def a; end',
'def b; end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'registers an offense for adjacent defs if some are multi-line' do
source = ['def a; end',
'def b; end',
'def c', # Not a one-liner, so this is an offense.
'end',
# Also an offense since previous was multi-line:
'def d; end']
inspect_source(cop, source)
expect(cop.offenses.map(&:line)).to eq([3, 5])
end
end
context 'when a maximum of empty lines is specified' do
let(:cop_config) { { 'NumberOfEmptyLines' => [0, 1] } }
it 'finds no offense for no empty line' do
source = ['def n',
'end',
'def o',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'finds no offense for one empty line' do
source = ['def n',
'end',
'',
'def o',
' end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'finds an offense for two empty lines' do
source = ['def n',
'end',
'',
'',
'def o',
'end']
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'auto-corrects' do
source = ['def n',
'end',
'',
'',
'def o',
'end']
corrected = autocorrect_source(cop, source)
expect(corrected).to eq(['def n',
'end',
'',
'def o',
'end'].join("\n"))
end
end
context 'when multiple lines between defs are allowed' do
let(:cop_config) { { 'NumberOfEmptyLines' => 2 } }
it 'treats lines with whitespaces as blank' do
source = ['def n',
'end',
'',
'def o',
'end']
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'auto-corrects when there are no new lines' do
source = ['def n',
'end',
'def o',
'end']
corrected = autocorrect_source(cop, source)
expect(corrected).to eq(['def n',
'end',
'',
'',
'def o',
'end'].join("\n"))
end
it 'auto-corrects when there are too few new lines' do
source = ['def n',
'end',
'',
'def o',
'end']
corrected = autocorrect_source(cop, source)
expect(corrected).to eq(['def n',
'end',
'',
'',
'def o',
'end'].join("\n"))
end
it 'auto-corrects when there are too many new lines' do
source = ['def n',
'end',
'',
'',
'',
'',
'def o',
'end']
corrected = autocorrect_source(cop, source)
expect(corrected).to eq(['def n',
'end',
'',
'',
'def o',
'end'].join("\n"))
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/empty_lines_around_access_modifier_spec.rb 0000664 0000000 0000000 00000016625 13070542236 0032131 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::EmptyLinesAroundAccessModifier do
subject(:cop) { described_class.new }
%w[private protected public module_function].each do |access_modifier|
it "requires blank line before #{access_modifier}" do
inspect_source(cop,
['class Test',
' something',
" #{access_modifier}",
'',
' def test; end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(["Keep a blank line before and after `#{access_modifier}`."])
end
it "requires blank line after #{access_modifier}" do
inspect_source(cop,
['class Test',
' something',
'',
" #{access_modifier}",
' def test; end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(["Keep a blank line before and after `#{access_modifier}`."])
end
it "ignores comment line before #{access_modifier}" do
inspect_source(cop,
['class Test',
' something',
'',
' # This comment is fine',
" #{access_modifier}",
'',
' def test; end',
'end'])
expect(cop.offenses).to be_empty
end
it "ignores #{access_modifier} inside a method call" do
inspect_source(cop,
['class Test',
' def #{access_modifier}?',
" #{access_modifier}",
' end',
'end'])
expect(cop.offenses).to be_empty
end
it "ignores #{access_modifier} deep inside a method call" do
inspect_source(cop,
['class Test',
" def #{access_modifier}?",
' if true',
" #{access_modifier}",
' end',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it "ignores #{access_modifier} with a right-hand-side condition" do
inspect_source(cop,
['class Test',
" def #{access_modifier}?",
" #{access_modifier} if true",
' end',
'end'])
expect(cop.offenses).to be_empty
end
it "autocorrects blank line before #{access_modifier}" do
corrected = autocorrect_source(cop,
['class Test',
' something',
" #{access_modifier}",
'',
' def test; end',
'end'])
expect(corrected).to eq(['class Test',
' something',
'',
" #{access_modifier}",
'',
' def test; end',
'end'].join("\n"))
end
it 'autocorrects blank line after #{access_modifier}' do
corrected = autocorrect_source(cop,
['class Test',
' something',
'',
" #{access_modifier}",
' def test; end',
'end'])
expect(corrected).to eq(['class Test',
' something',
'',
" #{access_modifier}",
'',
' def test; end',
'end'].join("\n"))
end
it 'accepts missing blank line when at the beginning of class/module' do
inspect_source(cop,
['class Test',
" #{access_modifier}",
'',
' def test; end',
'end'])
expect(cop.offenses).to be_empty
end
it "requires blank line after, but not before, #{access_modifier} " \
'when at the beginning of class/module' do
inspect_source(cop,
['class Test',
" #{access_modifier}",
' def test',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(["Keep a blank line after `#{access_modifier}`."])
end
context 'at the beginning of block' do
context 'for blocks defined with do' do
it 'accepts missing blank line' do
inspect_source(cop,
['included do',
" #{access_modifier}",
'',
' def test; end',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts missing blank line with arguments' do
inspect_source(cop,
['included do |foo|',
" #{access_modifier}",
'',
' def test; end',
'end'])
expect(cop.offenses).to be_empty
end
it "requires blank line after, but not before, #{access_modifier}" do
inspect_source(cop,
['included do',
" #{access_modifier}",
' def test',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(["Keep a blank line after `#{access_modifier}`."])
end
end
context 'for blocks defined with {}' do
it 'accepts missing blank line' do
inspect_source(cop,
['included {',
" #{access_modifier}",
'',
' def test; end',
'}'])
expect(cop.offenses).to be_empty
end
it 'accepts missing blank line with arguments' do
inspect_source(cop,
['included { |foo|',
" #{access_modifier}",
'',
' def test; end',
'}'])
expect(cop.offenses).to be_empty
end
end
end
it 'accepts missing blank line when at the end of block' do
inspect_source(cop,
['class Test',
' def test; end',
'',
" #{access_modifier}",
'end'])
expect(cop.offenses).to be_empty
end
it 'recognizes blank lines with DOS style line endings' do
inspect_source(cop,
["class Test\r",
"\r",
" #{access_modifier}\r",
"\r",
" def test; end\r",
"end\r"])
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/empty_lines_around_begin_body_spec.rb 0000664 0000000 0000000 00000007177 13070542236 0031115 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::EmptyLinesAroundBeginBody do
let(:config) { RuboCop::Config.new }
subject(:cop) { described_class.new(config) }
shared_examples :offense do |name, message, code, correction|
it "registers an offense for #{name} with a blank" do
inspect_source(cop, code.strip_indent)
message = "Extra empty line detected at `begin` body #{message}."
expect(cop.messages).to eq([message])
end
it "autocorrects for #{name} with a blank" do
corrected = autocorrect_source(cop, code.strip_indent)
expect(corrected).to eq(correction.strip_indent)
end
end
shared_examples :accepts do |name, code|
it "accepts #{name}" do
inspect_source(cop, code)
expect(cop.offenses).to be_empty
end
end
include_examples :offense, 'begin body starting', 'beginning',
<<-CODE, <<-CORRECTION
begin
foo
end
CODE
begin
foo
end
CORRECTION
include_examples :offense, 'begin body ending', 'end', <<-CODE, <<-CORRECTION
begin
foo
end
CODE
begin
foo
end
CORRECTION
include_examples :offense,
'begin body starting in method', 'beginning',
<<-CODE, <<-CORRECTION
def bar
begin
foo
end
end
CODE
def bar
begin
foo
end
end
CORRECTION
include_examples :offense,
'begin body ending in method', 'end', <<-CODE, <<-CORRECTION
def bar
begin
foo
end
end
CODE
def bar
begin
foo
end
end
CORRECTION
include_examples :offense,
'begin body starting with rescue', 'beginning',
<<-CODE, <<-CORRECTION
begin
foo
rescue
bar
end
CODE
begin
foo
rescue
bar
end
CORRECTION
include_examples :offense, 'rescue body ending', 'end', <<-CODE, <<-CORRECTION
begin
foo
rescue
bar
end
CODE
begin
foo
rescue
bar
end
CORRECTION
include_examples :offense, 'else body ending', 'end', <<-CODE, <<-CORRECTION
begin
foo
rescue
bar
else
baz
end
CODE
begin
foo
rescue
bar
else
baz
end
CORRECTION
include_examples :offense, 'ensure body ending', 'end', <<-CODE, <<-CORRECTION
begin
foo
ensure
bar
end
CODE
begin
foo
ensure
bar
end
CORRECTION
context 'with complex begin-end' do
let(:source) { <<-END.strip_indent }
begin
do_something1
rescue RuntimeError
do_something2
rescue ArgumentError => ex
do_something3
rescue
do_something3
else
do_something4
ensure
do_something4
end
END
let(:correction) { <<-END.strip_indent }
begin
do_something1
rescue RuntimeError
do_something2
rescue ArgumentError => ex
do_something3
rescue
do_something3
else
do_something4
ensure
do_something4
end
END
it 'registers many offenses' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(2)
end
it 'autocorrects' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq correction
end
end
include_examples :accepts, 'begin block without empty line', <<-END
begin
foo
end
END
include_examples :accepts,
'begin block without empty line in a method', <<-END
def foo
begin
bar
end
end
END
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/empty_lines_around_block_body_spec.rb 0000664 0000000 0000000 00000007054 13070542236 0031115 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::EmptyLinesAroundBlockBody, :config do
subject(:cop) { described_class.new(config) }
# Test blocks using both {} and do..end
[%w[{ }], %w[do end]].each do |open, close|
context "when EnforcedStyle is no_empty_lines for #{open} #{close} block" do
let(:cop_config) { { 'EnforcedStyle' => 'no_empty_lines' } }
it 'registers an offense for block body starting with a blank' do
inspect_source(cop,
["some_method #{open}",
'',
' do_something',
close])
expect(cop.messages)
.to eq(['Extra empty line detected at block body beginning.'])
end
it 'autocorrects block body containing only a blank' do
corrected = autocorrect_source(cop,
["some_method #{open}",
'',
close])
expect(corrected).to eq ["some_method #{open}",
close].join("\n")
end
it 'registers an offense for block body ending with a blank' do
inspect_source(cop,
["some_method #{open}",
' do_something',
'',
close])
expect(cop.messages)
.to eq(['Extra empty line detected at block body end.'])
end
it 'accepts block body starting with a line with spaces' do
inspect_source(cop,
["some_method #{open}",
' ',
' do_something',
close])
expect(cop.offenses).to be_empty
end
it 'is not fooled by single line blocks' do
inspect_source(cop,
["some_method #{open} do_something #{close}",
'',
'something_else'])
expect(cop.offenses).to be_empty
end
end
context "when EnforcedStyle is empty_lines for #{open} #{close} block" do
let(:cop_config) { { 'EnforcedStyle' => 'empty_lines' } }
it 'registers an offense for block body not starting or ending with a ' \
'blank' do
inspect_source(cop,
["some_method #{open}",
' do_something',
close])
expect(cop.messages).to eq(['Empty line missing at block body '\
'beginning.',
'Empty line missing at block body end.'])
end
it 'ignores block with an empty body' do
source = "some_method #{open}\n#{close}"
corrected = autocorrect_source(cop, source)
expect(corrected).to eq(source)
end
it 'autocorrects beginning and end' do
new_source = autocorrect_source(cop,
["some_method #{open}",
' do_something',
close])
expect(new_source).to eq(["some_method #{open}",
'',
' do_something',
'',
close].join("\n"))
end
it 'is not fooled by single line blocks' do
inspect_source(cop,
["some_method #{open} do_something #{close}",
'something_else'])
expect(cop.offenses).to be_empty
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/empty_lines_around_class_body_spec.rb 0000664 0000000 0000000 00000024335 13070542236 0031131 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::EmptyLinesAroundClassBody, :config do
subject(:cop) { described_class.new(config) }
let(:extra_begin) { 'Extra empty line detected at class body beginning.' }
let(:extra_end) { 'Extra empty line detected at class body end.' }
let(:missing_begin) { 'Empty line missing at class body beginning.' }
let(:missing_end) { 'Empty line missing at class body end.' }
let(:missing_def) { 'Empty line missing before first def definition' }
let(:missing_type) { 'Empty line missing before first class definition' }
context 'when EnforcedStyle is no_empty_lines' do
let(:cop_config) { { 'EnforcedStyle' => 'no_empty_lines' } }
it 'registers an offense for class body starting with a blank' do
inspect_source(cop,
['class SomeClass',
'',
' do_something',
'end'])
expect(cop.messages)
.to eq(['Extra empty line detected at class body beginning.'])
end
it 'autocorrects class body containing only a blank' do
corrected = autocorrect_source(cop,
['class SomeClass',
'',
'end'])
expect(corrected).to eq ['class SomeClass',
'end'].join("\n")
end
it 'registers an offense for class body ending with a blank' do
inspect_source(cop,
['class SomeClass',
' do_something',
'',
'end'])
expect(cop.messages)
.to eq(['Extra empty line detected at class body end.'])
end
it 'registers an offense for singleton class body starting with a blank' do
inspect_source(cop,
['class << self',
'',
' do_something',
'end'])
expect(cop.messages)
.to eq(['Extra empty line detected at class body beginning.'])
end
it 'autocorrects singleton class body containing only a blank' do
corrected = autocorrect_source(cop,
['class << self',
'',
'end'])
expect(corrected).to eq ['class << self',
'end'].join("\n")
end
it 'registers an offense for singleton class body ending with a blank' do
inspect_source(cop,
['class << self',
' do_something',
'',
'end'])
expect(cop.messages)
.to eq(['Extra empty line detected at class body end.'])
end
end
context 'when EnforcedStyle is empty_lines' do
let(:cop_config) { { 'EnforcedStyle' => 'empty_lines' } }
it 'registers an offense for class body not starting or ending with a ' \
'blank' do
inspect_source(cop,
['class SomeClass',
' do_something',
'end'])
expect(cop.messages).to eq(['Empty line missing at class body beginning.',
'Empty line missing at class body end.'])
end
it 'ignores classes with an empty body' do
source = "class SomeClass\nend"
corrected = autocorrect_source(cop, source)
expect(corrected).to eq(source)
end
it 'autocorrects beginning and end' do
new_source = autocorrect_source(cop,
['class SomeClass',
' do_something',
'end'])
expect(new_source).to eq(['class SomeClass',
'',
' do_something',
'',
'end'].join("\n"))
end
it 'registers an offense for singleton class body not starting or ending ' \
'with a blank' do
inspect_source(cop,
['class << self',
' do_something',
'end'])
expect(cop.messages).to eq(['Empty line missing at class body beginning.',
'Empty line missing at class body end.'])
end
it 'ignores singleton classes with an empty body' do
source = "class << self\nend"
corrected = autocorrect_source(cop, source)
expect(corrected).to eq(source)
end
it 'autocorrects beginning and end for `class << self`' do
new_source = autocorrect_source(cop,
['class << self',
' do_something',
'end'])
expect(new_source).to eq(['class << self',
'',
' do_something',
'',
'end'].join("\n"))
end
end
context 'when EnforcedStyle is empty_lines_except_namespace' do
let(:cop_config) { { 'EnforcedStyle' => 'empty_lines_except_namespace' } }
context 'when only child is class' do
it 'requires no empty lines for namespace' do
inspect_source(cop,
['class Parent < Base',
' class Child',
'',
' do_something',
'',
' end',
'end'])
expect(cop.messages).to eq([])
end
it 'registers offence for namespace body starting with a blank' do
inspect_source(cop,
['class Parent',
'',
' class Child',
'',
' do_something',
'',
' end',
'end'])
expect(cop.messages).to eq([extra_begin])
end
it 'registers offence for namespace body ending with a blank' do
inspect_source(cop,
['class Parent',
' class Child',
'',
' do_something',
'',
' end',
'',
'end'])
expect(cop.messages).to eq([extra_end])
end
it 'registers offences for namespaced class body not starting '\
'with a blank' do
inspect_source(cop,
['class Parent',
' class Child',
' do_something',
'',
' end',
'end'])
expect(cop.messages).to eq([missing_begin])
end
it 'registers offences for namespaced class body not ending '\
'with a blank' do
inspect_source(cop,
['class Parent',
' class Child',
'',
' do_something',
' end',
'end'])
expect(cop.messages).to eq([missing_end])
end
it 'autocorrects beginning and end' do
new_source = autocorrect_source(cop,
['class Parent < Base',
'',
' class Child',
' do_something',
' end',
'',
'end'])
expect(new_source).to eq(['class Parent < Base',
' class Child',
'',
' do_something',
'',
' end',
'end'].join("\n"))
end
end
context 'when only child is module' do
it 'requires no empty lines for namespace' do
inspect_source(cop,
['class Parent',
' module Child',
' do_something',
' end',
'end'])
expect(cop.messages).to eq([])
end
it 'registers offence for namespace body starting with a blank' do
inspect_source(cop,
['class Parent',
'',
' module Child',
' do_something',
' end',
'end'])
expect(cop.messages).to eq([extra_begin])
end
it 'registers offence for namespace body ending with a blank' do
inspect_source(cop,
['class Parent',
' module Child',
' do_something',
' end',
'',
'end'])
expect(cop.messages).to eq([extra_end])
end
end
context 'when has multiple child classes' do
it 'requires empty lines for namespace' do
inspect_source(cop,
['class Parent',
'',
' class Mom',
'',
' do_something',
'',
' end',
' class Dad',
'',
' end',
'',
'end'])
expect(cop.messages).to eq([])
end
it 'registers offences for namespace body starting '\
'and ending without a blank' do
inspect_source(cop,
['class Parent',
' class Mom',
'',
' do_something',
'',
' end',
' class Dad',
'',
' end',
'end'])
expect(cop.messages).to eq([missing_begin, missing_end])
end
end
end
include_examples 'empty_lines_around_class_or_module_body', 'class'
end
empty_lines_around_exception_handling_keywords_spec.rb 0000664 0000000 0000000 00000010242 13070542236 0034511 0 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style # frozen_string_literal: true
describe RuboCop::Cop::Style::EmptyLinesAroundExceptionHandlingKeywords do
let(:config) { RuboCop::Config.new }
subject(:cop) { described_class.new(config) }
shared_examples :offense do |name, message, code, correction|
it "registers an offense for #{name} with a blank" do
inspect_source(cop, code.strip_indent)
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(["Extra empty line detected #{message}."])
end
it "autocorrects for #{name} with a blank" do
corrected = autocorrect_source(cop, code.strip_indent)
expect(corrected).to eq(correction.strip_indent)
end
end
shared_examples :accepts do |name, code|
it "accepts #{name}" do
inspect_source(cop, code)
expect(cop.offenses).to be_empty
end
end
include_examples :offense,
'above rescue keyword',
'before the `rescue`',
<<-CODE, <<-CORRECTION
begin
f1
rescue
f2
end
CODE
begin
f1
rescue
f2
end
CORRECTION
include_examples :offense,
'rescue section starting',
'after the `rescue`',
<<-CODE, <<-CORRECTION
begin
f1
rescue
f2
end
CODE
begin
f1
rescue
f2
end
CORRECTION
include_examples :offense,
'rescue section ending',
'before the `else`',
<<-CODE, <<-CORRECTION
begin
f1
rescue
f2
else
f3
end
CODE
begin
f1
rescue
f2
else
f3
end
CORRECTION
include_examples :offense,
'rescue section ending for method definition',
'before the `else`',
<<-CODE, <<-CORRECTION
def foo
f1
rescue
f2
else
f3
end
CODE
def foo
f1
rescue
f2
else
f3
end
CORRECTION
include_examples :accepts, 'no empty line', <<-END
begin
f1
rescue
f2
else
f3
ensure
f4
end
END
include_examples :accepts, 'empty lines around begin body', <<-END
begin
f1
end
END
include_examples :accepts, 'empty begin', <<-END
begin
end
END
include_examples :accepts, 'empty method definition', <<-END
def foo
end
END
context 'with complex begin-end' do
let(:source) { <<-END.strip_indent }
begin
do_something1
rescue RuntimeError
do_something2
rescue ArgumentError => ex
do_something3
rescue
do_something3
else
do_something4
ensure
do_something4
end
END
let(:correction) { <<-END.strip_indent }
begin
do_something1
rescue RuntimeError
do_something2
rescue ArgumentError => ex
do_something3
rescue
do_something3
else
do_something4
ensure
do_something4
end
END
it 'registers many offenses' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(10)
end
it 'autocorrects' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq correction
end
end
context 'with complex method definition' do
let(:source) { <<-END.strip_indent }
def foo
do_something1
rescue RuntimeError
do_something2
rescue ArgumentError => ex
do_something3
rescue
do_something3
else
do_something4
ensure
do_something4
end
END
let(:correction) { <<-END.strip_indent }
def foo
do_something1
rescue RuntimeError
do_something2
rescue ArgumentError => ex
do_something3
rescue
do_something3
else
do_something4
ensure
do_something4
end
END
it 'registers many offenses' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(10)
end
it 'autocorrects' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq correction
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/empty_lines_around_method_body_spec.rb 0000664 0000000 0000000 00000006023 13070542236 0031276 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::EmptyLinesAroundMethodBody do
subject(:cop) { described_class.new }
it 'registers an offense for method body starting with a blank' do
inspect_source(cop,
['def some_method',
'',
' do_something',
'end'])
expect(cop.messages)
.to eq(['Extra empty line detected at method body beginning.'])
end
# The cop only registers an offense if the extra line is completely empty. If
# there is trailing whitespace, then that must be dealt with first. Having
# two cops registering offense for the line with only spaces would cause
# havoc in auto-correction.
it 'accepts method body starting with a line with spaces' do
inspect_source(cop,
['def some_method',
' ',
' do_something',
'end'])
expect(cop.offenses).to be_empty
end
it 'autocorrects method body starting with a blank' do
corrected = autocorrect_source(cop,
['def some_method',
'',
' do_something',
'end'])
expect(corrected).to eq ['def some_method',
' do_something',
'end'].join("\n")
end
it 'registers an offense for class method body starting with a blank' do
inspect_source(cop,
['def Test.some_method',
'',
' do_something',
'end'])
expect(cop.messages)
.to eq(['Extra empty line detected at method body beginning.'])
end
it 'autocorrects class method body starting with a blank' do
corrected = autocorrect_source(cop,
['def Test.some_method',
'',
' do_something',
'end'])
expect(corrected).to eq ['def Test.some_method',
' do_something',
'end'].join("\n")
end
it 'registers an offense for method body ending with a blank' do
inspect_source(cop,
['def some_method',
' do_something',
'',
'end'])
expect(cop.messages)
.to eq(['Extra empty line detected at method body end.'])
end
it 'registers an offense for class method body ending with a blank' do
inspect_source(cop,
['def Test.some_method',
' do_something',
'',
'end'])
expect(cop.messages)
.to eq(['Extra empty line detected at method body end.'])
end
it 'is not fooled by single line methods' do
inspect_source(cop,
['def some_method; do_something; end',
'',
'something_else'])
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/empty_lines_around_module_body_spec.rb 0000664 0000000 0000000 00000021146 13070542236 0031306 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::EmptyLinesAroundModuleBody, :config do
subject(:cop) { described_class.new(config) }
let(:extra_begin) { 'Extra empty line detected at module body beginning.' }
let(:extra_end) { 'Extra empty line detected at module body end.' }
let(:missing_begin) { 'Empty line missing at module body beginning.' }
let(:missing_end) { 'Empty line missing at module body end.' }
let(:missing_def) { 'Empty line missing before first def definition' }
let(:missing_type) { 'Empty line missing before first module definition' }
context 'when EnforcedStyle is no_empty_lines' do
let(:cop_config) { { 'EnforcedStyle' => 'no_empty_lines' } }
it 'registers an offense for module body starting with a blank' do
inspect_source(cop,
['module SomeModule',
'',
' do_something',
'end'])
expect(cop.messages)
.to eq(['Extra empty line detected at module body beginning.'])
end
it 'registers an offense for module body ending with a blank' do
inspect_source(cop,
['module SomeModule',
' do_something',
'',
'end'])
expect(cop.messages)
.to eq(['Extra empty line detected at module body end.'])
end
it 'autocorrects beginning and end' do
new_source = autocorrect_source(cop,
['module SomeModule',
'',
' do_something',
'',
'end'])
expect(new_source).to eq(['module SomeModule',
' do_something',
'end'].join("\n"))
end
end
context 'when EnforcedStyle is empty_lines' do
let(:cop_config) { { 'EnforcedStyle' => 'empty_lines' } }
it 'registers an offense for module body not starting or ending with a ' \
'blank' do
inspect_source(cop,
['module SomeModule',
' do_something',
'end'])
expect(cop.messages)
.to eq(['Empty line missing at module body beginning.',
'Empty line missing at module body end.'])
end
it 'registers an offense for module body not ending with a blank' do
inspect_source(cop,
['module SomeModule',
'',
' do_something',
'end'])
expect(cop.messages).to eq(['Empty line missing at module body end.'])
end
it 'autocorrects beginning and end' do
new_source = autocorrect_source(cop,
['module SomeModule',
' do_something',
'end'])
expect(new_source).to eq(['module SomeModule',
'',
' do_something',
'',
'end'].join("\n"))
end
it 'ignores modules with an empty body' do
source = "module A\nend"
corrected = autocorrect_source(cop, source)
expect(corrected).to eq(source)
end
end
context 'when EnforcedStyle is empty_lines_except_namespace' do
let(:cop_config) { { 'EnforcedStyle' => 'empty_lines_except_namespace' } }
context 'when only child is class' do
it 'requires no empty lines for namespace' do
inspect_source(cop,
['module Parent',
' module Child',
'',
' do_something',
'',
' end',
'end'])
expect(cop.messages).to eq([])
end
it 'registers offence for namespace body starting with a blank' do
inspect_source(cop,
['module Parent',
'',
' module Child',
'',
' do_something',
'',
' end',
'end'])
expect(cop.messages).to eq([extra_begin])
end
it 'registers offence for namespace body ending with a blank' do
inspect_source(cop,
['module Parent',
' module Child',
'',
' do_something',
'',
' end',
'',
'end'])
expect(cop.messages).to eq([extra_end])
end
it 'registers offences for namespaced module body not starting '\
'with a blank' do
inspect_source(cop,
['module Parent',
' module Child',
' do_something',
'',
' end',
'end'])
expect(cop.messages).to eq([missing_begin])
end
it 'registers offences for namespaced module body not ending '\
'with a blank' do
inspect_source(cop,
['module Parent',
' module Child',
'',
' do_something',
' end',
'end'])
expect(cop.messages).to eq([missing_end])
end
it 'autocorrects beginning and end' do
new_source = autocorrect_source(cop,
['module Parent',
'',
' module Child',
' do_something',
' end',
'',
'end'])
expect(new_source).to eq(['module Parent',
' module Child',
'',
' do_something',
'',
' end',
'end'].join("\n"))
end
end
context 'when only child is class' do
it 'requires no empty lines for namespace' do
inspect_source(cop,
['module Parent',
' class SomeClass',
' do_something',
' end',
'end'])
expect(cop.messages).to eq([])
end
it 'registers offence for namespace body starting with a blank' do
inspect_source(cop,
['module Parent',
'',
' class SomeClass',
' do_something',
' end',
'end'])
expect(cop.messages).to eq([extra_begin])
end
it 'registers offence for namespace body ending with a blank' do
inspect_source(cop,
['module Parent',
' class SomeClass',
' do_something',
' end',
'',
'end'])
expect(cop.messages).to eq([extra_end])
end
end
context 'when has multiple child modules' do
it 'requires empty lines for namespace' do
inspect_source(cop,
['module Parent',
'',
' module Mom',
'',
' do_something',
'',
' end',
' module Dad',
'',
' end',
'',
'end'])
expect(cop.messages).to eq([])
end
it 'registers offences for namespace body starting '\
'and ending without a blank' do
inspect_source(cop,
['module Parent',
' module Mom',
'',
' do_something',
'',
' end',
' module Dad',
'',
' end',
'end'])
expect(cop.messages).to eq([missing_begin, missing_end])
end
end
end
include_examples 'empty_lines_around_class_or_module_body', 'module'
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/empty_lines_spec.rb 0000664 0000000 0000000 00000002534 13070542236 0025354 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::EmptyLines do
subject(:cop) { described_class.new }
it 'registers an offense for consecutive empty lines' do
inspect_source(cop,
['test = 5', '', '', '', 'top'])
expect(cop.offenses.size).to eq(2)
end
it 'auto-corrects consecutive empty lines' do
corrected = autocorrect_source(cop,
['test = 5', '', '', '', 'top'])
expect(corrected).to eq ['test = 5', '', 'top'].join("\n")
end
it 'works when there are no tokens' do
inspect_source(cop,
'#comment')
expect(cop.offenses).to be_empty
end
it 'handles comments' do
inspect_source(cop,
['test', '', '#comment', 'top'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense for empty lines in a string' do
inspect_source(cop, 'result = "test
string"')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for heredocs with empty lines inside' do
inspect_source(cop, ['str = <<-TEXT',
'line 1',
'',
'',
'line 2',
'TEXT',
'puts str'])
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/empty_literal_spec.rb 0000664 0000000 0000000 00000013001 13070542236 0025665 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::EmptyLiteral do
subject(:cop) { described_class.new }
describe 'Empty Array' do
it 'registers an offense for Array.new()' do
inspect_source(cop, 'test = Array.new()')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use array literal `[]` instead of `Array.new`.'])
end
it 'registers an offense for Array.new' do
inspect_source(cop, 'test = Array.new')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use array literal `[]` instead of `Array.new`.'])
end
it 'does not register an offense for Array.new(3)' do
inspect_source(cop, 'test = Array.new(3)')
expect(cop.offenses).to be_empty
end
it 'auto-corrects Array.new to []' do
new_source = autocorrect_source(cop, 'test = Array.new')
expect(new_source).to eq('test = []')
end
it 'auto-corrects Array.new in block in block' do
source = 'puts { Array.new }'
new_source = autocorrect_source(cop, source)
expect(new_source).to eq 'puts { [] }'
end
it 'does not registers an offense Array.new with block' do
source = 'test = Array.new { 1 }'
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'does not register Array.new with block in other block' do
source = 'puts { Array.new { 1 } }'
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
describe 'Empty Hash' do
it 'registers an offense for Hash.new()' do
inspect_source(cop, 'test = Hash.new()')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use hash literal `{}` instead of `Hash.new`.'])
end
it 'registers an offense for Hash.new' do
inspect_source(cop, 'test = Hash.new')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use hash literal `{}` instead of `Hash.new`.'])
end
it 'does not register an offense for Hash.new(3)' do
inspect_source(cop, 'test = Hash.new(3)')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for Hash.new { block }' do
inspect_source(cop, 'test = Hash.new { block }')
expect(cop.offenses).to be_empty
end
it 'auto-corrects Hash.new to {}' do
new_source = autocorrect_source(cop, 'Hash.new')
expect(new_source).to eq('{}')
end
it 'auto-corrects Hash.new in block ' do
source = 'puts { Hash.new }'
new_source = autocorrect_source(cop, source)
expect(new_source).to eq 'puts { {} }'
end
it 'auto-corrects Hash.new to {} in various contexts' do
new_source =
autocorrect_source(cop, ['test = Hash.new',
'Hash.new.merge("a" => 3)',
'yadayada.map { a }.reduce(Hash.new, :merge)'])
expect(new_source)
.to eq(['test = {}',
'{}.merge("a" => 3)',
'yadayada.map { a }.reduce({}, :merge)'].join("\n"))
end
it 'auto-correct Hash.new to {} as the only parameter to a method' do
source = 'yadayada.map { a }.reduce Hash.new'
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('yadayada.map { a }.reduce({})')
end
it 'auto-correct Hash.new to {} as the first parameter to a method' do
source = 'yadayada.map { a }.reduce Hash.new, :merge'
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('yadayada.map { a }.reduce({}, :merge)')
end
end
describe 'Empty String' do
it 'registers an offense for String.new()' do
inspect_source(cop, 'test = String.new()')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(["Use string literal `''` instead of `String.new`."])
end
it 'registers an offense for String.new' do
inspect_source(cop, 'test = String.new')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(["Use string literal `''` instead of `String.new`."])
end
it 'does not register an offense for String.new("top")' do
inspect_source(cop, 'test = String.new("top")')
expect(cop.offenses).to be_empty
end
it 'auto-corrects String.new to empty string literal' do
new_source = autocorrect_source(cop, 'test = String.new')
expect(new_source).to eq("test = ''")
end
context 'when double-quoted string literals are preferred' do
let(:config) do
RuboCop::Config.new(
'Style/StringLiterals' =>
{
'EnforcedStyle' => 'double_quotes'
}
)
end
subject(:cop) { described_class.new(config) }
it 'registers an offense for String.new' do
inspect_source(cop, 'test = String.new')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use string literal `""` instead of `String.new`.'])
end
it 'auto-corrects String.new to a double-quoted empty string literal' do
new_source = autocorrect_source(cop, 'test = String.new')
expect(new_source).to eq('test = ""')
end
end
context 'when frozen string literals is enabled' do
let(:ruby_version) { 2.3 }
it 'does not register an offense for String.new' do
inspect_source(cop, ['# encoding: utf-8',
'# frozen_string_literal: true',
'test = String.new'])
expect(cop.offenses).to be_empty
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/empty_method_spec.rb 0000664 0000000 0000000 00000012543 13070542236 0025523 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::EmptyMethod, :config do
subject(:cop) { described_class.new(config) }
before do
inspect_source(cop, source)
end
shared_examples 'code with offense' do |code, expected|
context "when checking #{code}" do
let(:source) { code }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq([message])
end
if expected
it 'auto-corrects' do
expect(autocorrect_source(cop, code)).to eq(expected)
end
else
it 'does not auto-correct' do
expect(autocorrect_source(cop, code)).to eq(code)
end
end
end
end
shared_examples 'code without offense' do |code|
let(:source) { code }
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
context 'when configured with compact style' do
let(:cop_config) { { 'EnforcedStyle' => 'compact' } }
let(:message) { 'Put empty method definitions on a single line.' }
context 'with an empty instance method definition' do
it_behaves_like 'code with offense',
['def foo',
'end'].join("\n"),
'def foo; end'
it_behaves_like 'code with offense',
['def foo(bar, baz)',
'end'].join("\n"),
'def foo(bar, baz); end'
it_behaves_like 'code with offense',
['def foo',
'',
'end'].join("\n"),
'def foo; end'
it_behaves_like 'code without offense',
'def foo; end'
end
context 'with a non-empty instance method definition' do
it_behaves_like 'code without offense',
['def foo',
' bar',
'end']
it_behaves_like 'code without offense',
'def foo; bar; end'
it_behaves_like 'code without offense',
['def foo',
' # bar',
'end']
end
context 'with an empty class method definition' do
it_behaves_like 'code with offense',
['def self.foo',
'end'].join("\n"),
'def self.foo; end'
it_behaves_like 'code with offense',
['def self.foo(bar, baz)',
'end'].join("\n"),
'def self.foo(bar, baz); end'
it_behaves_like 'code with offense',
['def self.foo',
'',
'end'].join("\n"),
'def self.foo; end'
it_behaves_like 'code without offense',
'def self.foo; end'
end
context 'with a non-empty class method definition' do
it_behaves_like 'code without offense',
['def self.foo',
' bar',
'end']
it_behaves_like 'code without offense',
'def self.foo; bar; end'
it_behaves_like 'code without offense',
['def self.foo',
' # bar',
'end']
end
end
context 'when configured with expanded style' do
let(:cop_config) { { 'EnforcedStyle' => 'expanded' } }
let(:message) do
'Put the `end` of empty method definitions on the next line.'
end
context 'with an empty instance method definition' do
it_behaves_like 'code without offense',
['def foo',
'end'].join("\n")
it_behaves_like 'code without offense',
['def foo',
'',
'end'].join("\n")
it_behaves_like 'code with offense',
'def foo; end',
['def foo',
'end'].join("\n")
end
context 'with a non-empty instance method definition' do
it_behaves_like 'code without offense',
['def foo',
' bar',
'end']
it_behaves_like 'code without offense',
'def foo; bar; end'
it_behaves_like 'code without offense',
['def foo',
' # bar',
'end']
end
context 'with an empty class method definition' do
it_behaves_like 'code without offense',
['def self.foo',
'end'].join("\n")
it_behaves_like 'code without offense',
['def self.foo',
'',
'end'].join("\n")
it_behaves_like 'code with offense',
'def self.foo; end',
['def self.foo',
'end'].join("\n")
end
context 'with a non-empty class method definition' do
it_behaves_like 'code without offense',
['def self.foo',
' bar',
'end']
it_behaves_like 'code without offense',
'def self.foo; bar; end'
it_behaves_like 'code without offense',
['def self.foo',
' # bar',
'end']
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/encoding_spec.rb 0000664 0000000 0000000 00000017757 13070542236 0024627 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::Encoding, :config do
subject(:cop) { described_class.new(config) }
context 'when_needed' do
let(:cop_config) do
{ 'EnforcedStyle' => 'when_needed' }
end
it 'registers no offense when no encoding present but only ASCII ' \
'characters' do
inspect_source(cop, 'def foo() end')
expect(cop.offenses).to be_empty
end
it 'registers an offense when there is no encoding present but non ' \
'ASCII characters' do
inspect_source(cop, 'def foo() \'ä\' end')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['Missing utf-8 encoding comment.']
)
end
it 'registers an offense when encoding present but only ASCII ' \
'characters' do
inspect_source(cop, ['# encoding: utf-8',
'def foo() end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['Unnecessary utf-8 encoding comment.']
)
end
it 'accepts an empty file' do
inspect_source(cop, '')
expect(cop.offenses).to be_empty
end
it 'accepts encoding on first line' do
inspect_source(cop, ['# encoding: utf-8',
'def foo() \'ä\' end'])
expect(cop.offenses).to be_empty
end
it 'accepts encoding on second line when shebang present' do
inspect_source(cop, ['#!/usr/bin/env ruby',
'# encoding: utf-8',
'def foo() \'ä\' end'])
expect(cop.messages).to be_empty
end
it 'registers an offense when encoding is in the wrong place' do
inspect_source(cop, ['def foo() \'ä\' end',
'# encoding: utf-8'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['Missing utf-8 encoding comment.']
)
end
it 'accepts encoding inserted by magic_encoding gem' do
inspect_source(cop, ['# -*- encoding : utf-8 -*-',
'def foo() \'ä\' end'])
expect(cop.messages).to be_empty
end
it 'accepts vim-style encoding comments' do
inspect_source(cop, ['# vim:filetype=ruby, fileencoding=utf-8',
'def foo() \'ä\' end'])
expect(cop.messages).to be_empty
end
context 'auto-correct' do
it 'inserts an encoding comment on the first line when there are ' \
'non ASCII characters in the file' do
new_source = autocorrect_source(cop, 'def foo() \'ä\' end')
expect(new_source).to eq(['# encoding: utf-8',
'def foo() \'ä\' end'].join("\n"))
end
it "removes encoding comment on first line when it's not needed" do
new_source = autocorrect_source(cop, "# encoding: utf-8\nblah")
expect(new_source).to eq('blah')
end
end
end
context 'always' do
let(:cop_config) do
{ 'EnforcedStyle' => 'always' }
end
it 'registers an offense when no encoding present' do
inspect_source(cop, 'def foo() end')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['Missing utf-8 encoding comment.']
)
end
it 'accepts an empty file' do
inspect_source(cop, '')
expect(cop.offenses).to be_empty
end
it 'accepts encoding on first line' do
inspect_source(cop, ['# encoding: utf-8',
'def foo() end'])
expect(cop.offenses).to be_empty
end
it 'accepts encoding on second line when shebang present' do
inspect_source(cop, ['#!/usr/bin/env ruby',
'# encoding: utf-8',
'def foo() end'])
expect(cop.messages).to be_empty
end
it 'books an offense when encoding is in the wrong place' do
inspect_source(cop, ['def foo() end',
'# encoding: utf-8'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['Missing utf-8 encoding comment.']
)
end
it 'accepts encoding inserted by magic_encoding gem' do
inspect_source(cop, ['# -*- encoding : utf-8 -*-',
'def foo() end'])
expect(cop.messages).to be_empty
end
it 'accepts vim-style encoding comments' do
inspect_source(cop, ['# vim:filetype=ruby, fileencoding=utf-8',
'def foo() end'])
expect(cop.messages).to be_empty
end
context 'auto-correct' do
context 'valid auto correct encoding comment' do
it 'inserts an encoding comment on the first line of files without ' \
'a shebang' do
cop_config['AutoCorrectEncodingComment'] = '# encoding: utf-8'
new_source = autocorrect_source(cop, 'def foo() end')
expect(new_source).to eq("# encoding: utf-8\ndef foo() end")
end
it 'inserts an encoding comment on the first line and leaves ' \
'the wrong encoding line when encoding is in the wrong place' do
cop_config['AutoCorrectEncodingComment'] = '# encoding: utf-8'
new_source = autocorrect_source(cop, ['def foo() end',
'# encoding: utf-8'])
expect(new_source).to eq(['# encoding: utf-8',
'def foo() end',
'# encoding: utf-8'].join("\n"))
end
it 'inserts an encoding comment on the second line when the first ' \
'line is a shebang' do
new_source = autocorrect_source(cop, ['#!/usr/bin/env ruby',
'def foo',
'end'])
expect(new_source).to eq(['#!/usr/bin/env ruby',
'# encoding: utf-8',
'def foo',
'end'].join("\n"))
end
it "doesn't infinite-loop when the first line is blank" do
new_source = autocorrect_source(cop, ['',
'module Toto',
'end'])
expect(new_source).to eq(['# encoding: utf-8',
'',
'module Toto',
'end'].join("\n"))
end
end
context 'invalid auto correct comment' do
it 'throws an exception' do
cop_config['AutoCorrectEncodingComment'] = 'invalid'
expect { autocorrect_source(cop, 'def foo() end') }
.to raise_error(RuntimeError, 'invalid does not match ' \
'(?-mix:#.*coding\s?[:=]\s?(?:UTF|utf)-8)')
end
end
end
end
context 'never' do
let(:cop_config) do
{ 'EnforcedStyle' => 'never' }
end
it 'registers no offense when no encoding present but only ASCII ' \
'characters' do
inspect_source(cop, 'def foo() end')
expect(cop.offenses).to be_empty
end
it 'registers no offense when there is no encoding present but non ' \
'ASCII characters' do
inspect_source(cop, 'def foo() \'ä\' end')
expect(cop.offenses).to be_empty
end
it 'registers an offense when encoding present but only ASCII ' \
'characters' do
inspect_source(cop, ['# encoding: utf-8',
'def foo() end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['Unnecessary utf-8 encoding comment.']
)
end
context 'auto-correct' do
it 'removes encoding comment on first line when there are ' \
'non ASCII characters in the file' do
new_source = autocorrect_source(cop, 'def foo() \'ä\' end')
expect(new_source).to eq('def foo() \'ä\' end')
end
it "removes encoding comment on first line when it's not needed" do
new_source = autocorrect_source(cop, "# encoding: utf-8\nblah")
expect(new_source).to eq('blah')
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/end_block_spec.rb 0000664 0000000 0000000 00000000407 13070542236 0024741 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::EndBlock do
subject(:cop) { described_class.new }
it 'reports an offense for an END block' do
src = 'END { test }'
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/end_of_line_spec.rb 0000664 0000000 0000000 00000012223 13070542236 0025261 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::EndOfLine, :config do
subject(:cop) { described_class.new(config) }
shared_examples 'all configurations' do
it 'accepts an empty file' do
inspect_source_file(cop, '')
expect(cop.offenses).to be_empty
end
end
shared_examples 'iso-8859-15' do |eol|
it 'can inspect non-UTF-8 encoded source with proper encoding comment' do
inspect_source_file(cop, ["# coding: ISO-8859-15#{eol}",
"# Euro symbol: \xa4#{eol}"])
expect(cop.offenses.size).to eq(1)
end
end
context 'when EnforcedStyle is native' do
let(:cop_config) { { 'EnforcedStyle' => 'native' } }
let(:messages) do
['Carriage return character ' \
"#{RuboCop::Platform.windows? ? 'missing' : 'detected'}."]
end
it 'registers an offense for an incorrect EOL' do
inspect_source_file(cop, ['x=0', '', "y=1\r"])
expect(cop.messages).to eq(messages)
expect(cop.offenses.map(&:line))
.to eq([RuboCop::Platform.windows? ? 1 : 3])
end
end
context 'when EnforcedStyle is crlf' do
let(:cop_config) { { 'EnforcedStyle' => 'crlf' } }
let(:messages) { ['Carriage return character missing.'] }
include_examples 'all configurations'
it 'registers an offense for CR+LF' do
inspect_source_file(cop, ['x=0', '', "y=1\r"])
expect(cop.messages).to eq(messages)
expect(cop.offenses.map(&:line)).to eq([1])
end
it 'highlights the whole offending line' do
inspect_source_file(cop, ['x=0', '', "y=1\r"])
expect(cop.highlights).to eq(["x=0\n"])
end
it 'does not register offense for no CR at end of file' do
inspect_source_file(cop, 'x=0')
expect(cop.offenses).to be_empty
end
it 'does not register offenses after __END__' do
inspect_source(cop, ["x=0\r",
'__END__',
'x=0'])
expect(cop.offenses).to be_empty
end
context 'and there are many lines ending with LF' do
it 'registers only one offense' do
inspect_source_file(cop, ['x=0', '', 'y=1'].join("\n"))
expect(cop.messages.size).to eq(1)
end
include_examples 'iso-8859-15', ''
end
context 'and the default external encoding is US_ASCII' do
around do |example|
orig_encoding = Encoding.default_external
Encoding.default_external = Encoding::US_ASCII
example.run
Encoding.default_external = orig_encoding
end
it 'does not crash on UTF-8 encoded non-ascii characters' do
source = ['# encoding: UTF-8',
'class Epd::ReportsController < EpdAreaController',
" 'terecht bij uw ROM-coördinator.'",
'end'].join("\r\n")
inspect_source_file(cop, source)
expect(cop.offenses).to be_empty
end
include_examples 'iso-8859-15', ''
end
context 'and source is a string' do
it 'registers an offense' do
inspect_source(cop, "x=0\ny=1")
expect(cop.messages).to eq(['Carriage return character missing.'])
end
end
end
context 'when EnforcedStyle is lf' do
let(:cop_config) { { 'EnforcedStyle' => 'lf' } }
include_examples 'all configurations'
it 'registers an offense for CR+LF' do
inspect_source_file(cop, ['x=0', '', "y=1\r"])
expect(cop.messages).to eq(['Carriage return character detected.'])
expect(cop.offenses.map(&:line)).to eq([3])
end
it 'highlights the whole offending line' do
inspect_source_file(cop, ['x=0', '', "y=1\r"])
expect(cop.highlights).to eq(["y=1\r"])
end
it 'registers an offense for CR at end of file' do
inspect_source_file(cop, "x=0\r")
expect(cop.messages).to eq(['Carriage return character detected.'])
end
it 'does not register offenses after __END__' do
inspect_source(cop, ['x=0',
'__END__',
"x=0\r"])
expect(cop.offenses).to be_empty
end
context 'and there are many lines ending with CR+LF' do
it 'registers only one offense' do
inspect_source_file(cop, ['x=0', '', 'y=1'].join("\r\n"))
expect(cop.messages.size).to eq(1)
end
include_examples 'iso-8859-15', "\r"
end
context 'and the default external encoding is US_ASCII' do
around do |example|
orig_encoding = Encoding.default_external
Encoding.default_external = Encoding::US_ASCII
example.run
Encoding.default_external = orig_encoding
end
it 'does not crash on UTF-8 encoded non-ascii characters' do
source = ['# encoding: UTF-8',
'class Epd::ReportsController < EpdAreaController',
" 'terecht bij uw ROM-coördinator.'",
'end'].join("\n")
inspect_source_file(cop, source)
expect(cop.offenses).to be_empty
end
include_examples 'iso-8859-15', "\r"
end
context 'and source is a string' do
it 'registers an offense' do
inspect_source(cop, "x=0\r")
expect(cop.messages).to eq(['Carriage return character detected.'])
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/even_odd_spec.rb 0000664 0000000 0000000 00000011547 13070542236 0024613 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::EvenOdd do
subject(:cop) { described_class.new }
it 'registers an offense for x % 2 == 0' do
inspect_source(cop, 'x % 2 == 0')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Replace with `Integer#even?`.'])
end
it 'registers an offense for x % 2 != 0' do
inspect_source(cop, 'x % 2 != 0')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Replace with `Integer#odd?`.'])
end
it 'registers an offense for (x % 2) == 0' do
inspect_source(cop, '(x % 2) == 0')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Replace with `Integer#even?`.'])
end
it 'registers an offense for (x % 2) != 0' do
inspect_source(cop, '(x % 2) != 0')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Replace with `Integer#odd?`.'])
end
it 'registers an offense for x % 2 == 1' do
inspect_source(cop, 'x % 2 == 1')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Replace with `Integer#odd?`.'])
end
it 'registers an offense for x % 2 != 1' do
inspect_source(cop, 'x % 2 != 1')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Replace with `Integer#even?`.'])
end
it 'registers an offense for (x % 2) == 1' do
inspect_source(cop, '(x % 2) == 1')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Replace with `Integer#odd?`.'])
end
it 'registers an offense for (x % 2) != 1' do
inspect_source(cop, '(x % 2) != 1')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Replace with `Integer#even?`.'])
end
it 'registers an offense for (x.y % 2) != 1' do
inspect_source(cop, '(x.y % 2) != 1')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Replace with `Integer#even?`.'])
end
it 'registers an offense for (x(y) % 2) != 1' do
inspect_source(cop, '(x(y) % 2) != 1')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Replace with `Integer#even?`.'])
end
it 'accepts x % 3 == 0' do
inspect_source(cop, 'x % 3 == 0')
expect(cop.offenses).to be_empty
end
it 'accepts x % 3 != 0' do
inspect_source(cop, 'x % 3 != 0')
expect(cop.offenses).to be_empty
end
it 'converts x % 2 == 0 to #even?' do
corrected = autocorrect_source(cop, 'x % 2 == 0')
expect(corrected).to eq('x.even?')
end
it 'converts x % 2 != 0 to #odd?' do
corrected = autocorrect_source(cop, 'x % 2 != 0')
expect(corrected).to eq('x.odd?')
end
it 'converts (x % 2) == 0 to #even?' do
corrected = autocorrect_source(cop, '(x % 2) == 0')
expect(corrected).to eq('x.even?')
end
it 'converts (x % 2) != 0 to #odd?' do
corrected = autocorrect_source(cop, '(x % 2) != 0')
expect(corrected).to eq('x.odd?')
end
it 'converts x % 2 == 1 to odd?' do
corrected = autocorrect_source(cop, 'x % 2 == 1')
expect(corrected).to eq('x.odd?')
end
it 'converts x % 2 != 1 to even?' do
corrected = autocorrect_source(cop, 'x % 2 != 1')
expect(corrected).to eq('x.even?')
end
it 'converts (x % 2) == 1 to odd?' do
corrected = autocorrect_source(cop, '(x % 2) == 1')
expect(corrected).to eq('x.odd?')
end
it 'converts (y % 2) != 1 to even?' do
corrected = autocorrect_source(cop, '(y % 2) != 1')
expect(corrected).to eq('y.even?')
end
it 'converts (x.y % 2) != 1 to even?' do
corrected = autocorrect_source(cop, '(x.y % 2) != 1')
expect(corrected).to eq('x.y.even?')
end
it 'converts (x(y) % 2) != 1 to even?' do
corrected = autocorrect_source(cop, '(x(y) % 2) != 1')
expect(corrected).to eq('x(y).even?')
end
it 'converts (x._(y) % 2) != 1 to even?' do
corrected = autocorrect_source(cop, '(x._(y) % 2) != 1')
expect(corrected).to eq('x._(y).even?')
end
it 'converts (x._(y)) % 2 != 1 to even?' do
corrected = autocorrect_source(cop, '(x._(y)) % 2 != 1')
expect(corrected).to eq('(x._(y)).even?')
end
it 'converts x._(y) % 2 != 1 to even?' do
corrected = autocorrect_source(cop, 'x._(y) % 2 != 1')
expect(corrected).to eq('x._(y).even?')
end
it 'converts 1 % 2 != 1 to even?' do
corrected = autocorrect_source(cop, '1 % 2 != 1')
expect(corrected).to eq('1.even?')
end
it 'converts complex examples' do
corrected = autocorrect_source(cop, [
'if (y % 2) != 1',
' method == :== ? :even : :odd',
'elsif x % 2 == 1',
' method == :== ? :odd : :even',
'end'
])
expect(corrected).to eq([
'if y.even?',
' method == :== ? :even : :odd',
'elsif x.odd?',
' method == :== ? :odd : :even',
'end'
].join("\n"))
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/extra_spacing_spec.rb 0000664 0000000 0000000 00000030575 13070542236 0025661 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::ExtraSpacing, :config do
subject(:cop) { described_class.new(config) }
shared_examples 'common behavior' do
it 'registers an offense for alignment with token not preceded by space' do
# The = and the ( are on the same column, but this is not for alignment,
# it's just a mistake.
inspect_source(cop, ['website("example.org")',
'name = "Jill"'])
expect(cop.offenses.size).to eq(1)
end
it 'accepts aligned values of an implicit hash literal' do
source = ["register(street1: '1 Market',",
" street2: '#200',",
" :city => 'Some Town',",
" state: 'CA',",
" postal_code:'99999-1111')"]
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'accepts space between key and value in a hash with hash rockets' do
source = [
'ospf_h = {',
" 'ospfTest' => {",
" 'foo' => {",
" area: '0.0.0.0', cost: 10, hello: 30, pass: true },",
" 'longname' => {",
" area: '1.1.1.38', pass: false },",
" 'vlan101' => {",
" area: '2.2.2.101', cost: 5, hello: 20, pass: true }",
' },',
" 'TestOspfInt' => {",
" 'x' => {",
" area: '0.0.0.19' },",
" 'vlan290' => {",
" area: '2.2.2.29', cost: 200, hello: 30, pass: true },",
" 'port-channel100' => {",
" area: '3.2.2.29', cost: 25, hello: 50, pass: false }",
' }',
'}'
]
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
context 'when spaces are present in a single-line hash literal' do
it 'registers an offense for hashes with symbol keys' do
inspect_source(cop, 'hash = {a: 1, b: 2}')
expect(cop.offenses.size).to eq(3)
end
it 'registers an offense for hashes with hash rockets' do
source = [
'let(:single_line_hash) {',
' {"a" => "1", "b" => "2"}',
'}'
]
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line).to eq(2)
end
end
it 'can handle extra space before a float' do
source = ['{:a => "a",',
' :b => [nil, 2.5]}']
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'can handle unary plus in an argument list' do
source = ['assert_difference(MyModel.count, +2,',
' 3, +3,', # Extra spacing only here.
' 4,+4)']
inspect_source(cop, source)
expect(cop.offenses.map { |o| o.location.line }).to eq([2])
end
it 'gives the correct line' do
inspect_source(cop, ['class A < String',
'end'])
expect(cop.offenses.first.location.line).to eq(1)
end
it 'registers an offense for double extra spacing on variable assignment' do
inspect_source(cop, 'm = "hello"')
expect(cop.offenses.size).to eq(1)
end
it 'ignores whitespace at the beginning of the line' do
inspect_source(cop, ' m = "hello"')
expect(cop.offenses).to be_empty
end
it 'ignores whitespace inside a string' do
inspect_source(cop, 'm = "hello this"')
expect(cop.offenses).to be_empty
end
it 'ignores trailing whitespace' do
inspect_source(cop, [' class Benchmarker < Performer ',
' end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense on class inheritance' do
inspect_source(cop, ['class A < String',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'auto-corrects a line indented with mixed whitespace' do
new_source = autocorrect_source(cop, ['website("example.org")',
'name = "Jill"'])
expect(new_source).to eq(['website("example.org")',
'name = "Jill"'].join("\n"))
end
it 'auto-corrects the class inheritance' do
new_source = autocorrect_source(cop, ['class A < String',
'end'])
expect(new_source).to eq(['class A < String',
'end'].join("\n"))
end
end
SOURCES = {
'lining up assignments' => [
'website = "example.org"',
'name = "Jill"'
],
'lining up assignments with empty lines and comments in between' => [
'a += 1',
'',
'# Comment',
'aa = 2',
'bb = 3',
'',
'a ||= 1'
],
'aligning with the same character' => [
' y, m = (year * 12 + (mon - 1) + n).divmod(12)',
' m, = (m + 1) .divmod(1)'
],
'lining up different kinds of assignments' => [
'type_name ||= value.class.name if value',
'type_name = type_name.to_s if type_name',
'',
'type_name = value.class.name if value',
'type_name += type_name.to_s unless type_name',
'',
'a += 1',
'aa -= 2'
],
'aligning comments on non-adjacent lines' => [
%(include_examples 'aligned', 'var = until', 'test'),
'',
%(include_examples 'unaligned', "var = if", 'test')
],
'aligning = on lines where there are trailing comments' => [
'a_long_var_name = 100 # this is 100',
'short_name1 = 2',
'',
'clear',
'',
'short_name2 = 2',
'a_long_var_name = 100 # this is 100',
'',
'clear',
'',
'short_name3 = 2 # this is 2',
'a_long_var_name = 100 # this is 100'
],
'aligning tokens with empty line between' => [
'unless nochdir',
' Dir.chdir "/" # Release old working directory.',
'end',
'',
'File.umask 0000 # Ensure sensible umask.'
],
'aligning long assignment expressions that include line breaks' => [
'size_attribute_name = FactoryGirl.create(:attribute,',
" name: 'Size',",
' values: %w{small large})',
'carrier_attribute_name = FactoryGirl.create(:attribute,',
" name: 'Carrier',",
' values: %w{verizon})'
]
}.freeze
context 'when AllowForAlignment is true' do
let(:cop_config) do
{ 'AllowForAlignment' => true, 'ForceEqualSignAlignment' => false }
end
include_examples 'common behavior'
context 'with extra spacing for alignment purposes' do
SOURCES.each do |reason, src|
context "such as #{reason}" do
it 'allows it' do
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
end
end
end
end
context 'when AllowForAlignment is false' do
let(:cop_config) do
{ 'AllowForAlignment' => false, 'ForceEqualSignAlignment' => false }
end
include_examples 'common behavior'
context 'with extra spacing for alignment purposes' do
SOURCES.each do |reason, src|
context "such as #{reason}" do
it 'registers offense(s)' do
inspect_source(cop, src)
expect(cop.offenses).not_to be_empty
end
end
end
end
end
context 'when ForceEqualSignAlignment is true' do
let(:cop_config) do
{ 'AllowForAlignment' => true, 'ForceEqualSignAlignment' => true }
end
it 'registers an offense if consecutive assignments are not aligned' do
inspect_source(cop, ['a = 1',
'bb = 2',
'ccc = 3'])
expect(cop.offenses.size).to eq(3)
expect(cop.messages).to eq(
['`=` is not aligned with the following assignment.',
'`=` is not aligned with the preceding assignment.',
'`=` is not aligned with the preceding assignment.']
)
end
it 'does not register an offense if assignments are separated by blanks' do
inspect_source(cop, ['a = 1',
'',
'bb = 2',
'',
'ccc = 3'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense if assignments are aligned' do
inspect_source(cop, ['a = 1',
'bb = 2',
'ccc = 3'])
expect(cop.offenses).to be_empty
end
it 'aligns the first assignment with the following assignment' do
inspect_source(cop, ['# comment',
'a = 1',
'bb = 2'])
expect(cop.offenses).to be_empty
end
it 'autocorrects consecutive assignments which are not aligned' do
new_source = autocorrect_source(cop, ['a = 1',
'bb = 2',
'ccc = 3',
'',
'abcde = 1',
'a = 2',
'abc = 3'])
expect(new_source).to eq(['a = 1',
'bb = 2',
'ccc = 3',
'',
'abcde = 1',
'a = 2',
'abc = 3'].join("\n"))
end
it 'autocorrects consecutive operator assignments which are not aligned' do
new_source = autocorrect_source(cop, ['a += 1',
'bb = 2',
'ccc <<= 3',
'',
'abcde = 1',
'a *= 2',
'abc ||= 3'])
expect(new_source).to eq(['a += 1',
'bb = 2',
'ccc <<= 3',
'',
'abcde = 1',
'a *= 2',
'abc ||= 3'].join("\n"))
end
it 'autocorrects consecutive aref assignments which are not aligned' do
new_source = autocorrect_source(cop, ['a[1] = 1',
'bb[2,3] = 2',
'ccc[:key] = 3',
'',
'abcde[0] = 1',
'a = 2',
'abc += 3'])
expect(new_source).to eq(['a[1] = 1',
'bb[2,3] = 2',
'ccc[:key] = 3',
'',
'abcde[0] = 1',
'a = 2',
'abc += 3'].join("\n"))
end
it 'autocorrects consecutive attribute assignments which are not aligned' do
new_source = autocorrect_source(cop, ['a.attr = 1',
'bb &&= 2',
'ccc.s = 3',
'',
'abcde.blah = 1',
'a.attribute_name = 2',
'abc[1] = 3'])
expect(new_source).to eq(['a.attr = 1',
'bb &&= 2',
'ccc.s = 3',
'',
'abcde.blah = 1',
'a.attribute_name = 2',
'abc[1] = 3'].join("\n"))
end
it 'does not register an offense when optarg equals is not aligned with ' \
'assignment equals sign' do
inspect_source(cop, ['def method(arg = 1)',
' var = arg',
'end'])
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/file_name_spec.rb 0000664 0000000 0000000 00000021777 13070542236 0024755 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::FileName do
subject(:cop) { described_class.new(config) }
let(:config) do
RuboCop::Config.new(
{ 'AllCops' => { 'Include' => includes },
'Style/FileName' => cop_config },
'/some/.rubocop.yml'
)
end
let(:cop_config) do
{
'IgnoreExecutableScripts' => true,
'ExpectMatchingDefinition' => false,
'Regex' => nil
}
end
let(:includes) { [] }
let(:source) { ['print 1'] }
let(:processed_source) { parse_source(source) }
before do
allow(processed_source.buffer)
.to receive(:name).and_return(filename)
_investigate(cop, processed_source)
end
context 'with camelCase file names ending in .rb' do
let(:filename) { '/some/dir/testCase.rb' }
it 'reports an offense' do
expect(cop.offenses.size).to eq(1)
end
end
context 'with camelCase file names without file extension' do
let(:filename) { '/some/dir/testCase' }
it 'reports an offense' do
expect(cop.offenses.size).to eq(1)
end
end
context 'with snake_case file names ending in .rb' do
let(:filename) { '/some/dir/test_case.rb' }
it 'reports an offense' do
expect(cop.offenses).to be_empty
end
end
context 'with snake_case file names without file extension' do
let(:filename) { '/some/dir/test_case' }
it 'does not report an offense' do
expect(cop.offenses).to be_empty
end
end
context 'with snake_case file names with non-rb extension' do
let(:filename) { '/some/dir/some_task.rake' }
it 'does not report an offense' do
expect(cop.offenses).to be_empty
end
end
context 'with snake_case file names with multiple extensions' do
let(:filename) { 'some/dir/some_view.html.slim_spec.rb' }
it 'does not report an offense' do
expect(cop.offenses).to be_empty
end
end
context 'with snake_case names which use ? and !' do
let(:filename) { 'some/dir/file?!.rb' }
it 'does not report an offense' do
expect(cop.offenses).to be_empty
end
end
context 'with non-snake-case file names with a shebang' do
let(:filename) { '/some/dir/test-case' }
let(:source) { ['#!/usr/bin/env ruby', 'print 1'] }
it 'does not report an offense' do
expect(cop.offenses).to be_empty
end
context 'when IgnoreExecutableScripts is disabled' do
let(:cop_config) { { 'IgnoreExecutableScripts' => false } }
it 'reports an offense' do
expect(cop.offenses.size).to eq(1)
end
end
end
context 'when the file is specified in AllCops/Include' do
let(:includes) { ['**/Gemfile'] }
context 'with a non-snake_case file name' do
let(:filename) { '/some/dir/Gemfile' }
it 'does not report an offense' do
expect(cop.offenses).to be_empty
end
end
end
context 'when ExpectMatchingDefinition is true' do
let(:cop_config) do
{ 'IgnoreExecutableScripts' => true, 'ExpectMatchingDefinition' => true }
end
context 'on a file which defines no class or module at all' do
%w[lib src test spec].each do |dir|
context "under #{dir}" do
let(:filename) { "/some/dir/#{dir}/file/test_case.rb" }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['test_case.rb should define a class ' \
'or module called `File::TestCase`.'])
end
end
end
context 'under some other random directory' do
let(:filename) { '/some/other/dir/test_case.rb' }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['test_case.rb should define a class ' \
'or module called `TestCase`.'])
end
end
end
context 'on an empty file' do
let(:source) { '' }
let(:filename) { '/lib/rubocop/blah.rb' }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['blah.rb should define a class ' \
'or module called `Rubocop::Blah`.'])
end
end
context 'on an empty file with a space in its filename' do
let(:source) { '' }
let(:filename) { 'a file.rb' }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['The name of this source file (`a file.rb`) ' \
'should use snake_case.'])
end
end
shared_examples 'matching module or class' do
%w[lib src test spec].each do |dir|
context "in a matching directory under #{dir}" do
let(:filename) { "/some/dir/#{dir}/a/b.rb" }
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
context "in a non-matching directory under #{dir}" do
let(:filename) { "/some/dir/#{dir}/c/b.rb" }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['b.rb should define a class ' \
'or module called `C::B`.'])
end
end
context "in a directory with multiple instances of #{dir}" do
let(:filename) { "/some/dir/#{dir}/project/#{dir}/a/b.rb" }
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
end
context 'in a directory elsewhere which only matches the module name' do
let(:filename) { '/some/dir/b.rb' }
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
context 'in a directory elsewhere which does not match the module name' do
let(:filename) { '/some/dir/e.rb' }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['e.rb should define a class ' \
'or module called `E`.'])
end
end
end
context 'on a file which defines a nested module' do
let(:source) do
['module A',
' module B',
' end',
'end']
end
include_examples 'matching module or class'
end
context 'on a file which defines a nested class' do
let(:source) do
['module A',
' class B',
' end',
'end']
end
include_examples 'matching module or class'
end
context 'on a file which uses Name::Spaced::Module syntax' do
let(:source) do
['begin',
' module A::B',
' end',
'end']
end
include_examples 'matching module or class'
end
context 'on a file which defines multiple classes' do
let(:source) do
['class X',
'end',
'module M',
'end',
'class A',
' class B',
' end',
'end']
end
include_examples 'matching module or class'
end
end
context 'when Regex is set' do
let(:cop_config) { { 'Regex' => /\A[aeiou]\z/i } }
context 'with a matching name' do
let(:filename) { 'a.rb' }
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
context 'with a non-matching name' do
let(:filename) { 'z.rb' }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['`z.rb` should match `(?i-mx:\\A[aeiou]\\z)`.']
)
end
end
end
context 'with acronym namespace' do
let(:cop_config) do
{
'IgnoreExecutableScripts' => true,
'ExpectMatchingDefinition' => true,
'AllowedAcronyms' => ['CLI']
}
end
let(:filename) { '/lib/my/cli/admin_user.rb' }
let(:source) do
[
'module My',
' module CLI',
' class AdminUser',
' end',
' end',
'end'
]
end
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
context 'with acronym class name' do
let(:cop_config) do
{
'IgnoreExecutableScripts' => true,
'ExpectMatchingDefinition' => true,
'AllowedAcronyms' => ['CLI']
}
end
let(:filename) { '/lib/my/cli.rb' }
let(:source) do
[
'module My',
' class CLI',
' end',
'end'
]
end
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
context 'with include acronym name' do
let(:cop_config) do
{
'IgnoreExecutableScripts' => true,
'ExpectMatchingDefinition' => true,
'AllowedAcronyms' => ['HTTP']
}
end
let(:filename) { '/lib/my/http_server.rb' }
let(:source) do
[
'module My',
' class HTTPServer',
' end',
'end'
]
end
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/first_array_element_line_break_spec.rb 0000664 0000000 0000000 00000006335 13070542236 0031240 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::FirstArrayElementLineBreak do
subject(:cop) { described_class.new }
context 'elements listed on the first line' do
let(:source) do
['a = [:a,',
' :b]']
end
it 'detects the offense' do
inspect_source(cop, source)
expect(cop.offenses.length).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq([':a'])
end
it 'autocorrects the offense' do
new_source = autocorrect_source(cop, source)
# Alignment for the first element is set by IndentationWidth cop,
# the rest of the elements should be aligned using the AlignArray cop.
expect(new_source).to eq("a = [\n:a,\n :b]")
end
end
context 'word arrays' do
let(:source) do
['%w(a b',
' c d)']
end
it 'detects the offense' do
inspect_source(cop, source)
expect(cop.offenses.length).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['a'])
end
it 'autocorrects the offense' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("%w(\na b\n c d)")
end
end
context 'array nested in a method call' do
let(:source) do
['method([:foo,',
' :bar])']
end
it 'detects the offense' do
inspect_source(cop, source)
expect(cop.offenses.length).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq([':foo'])
end
it 'autocorrects the offense' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(
"method([\n" \
":foo,\n" \
' :bar])'
)
end
end
context 'masgn implicit arrays' do
let(:source) do
['a, b,',
'c = 1,',
'2, 3']
end
let(:correct_source) do
['a, b,',
'c = ',
'1,',
'2, 3'].join("\n")
end
it 'detects the offense' do
inspect_source(cop, source)
expect(cop.offenses.length).to eq(1)
expect(cop.offenses.first.line).to eq(2)
expect(cop.highlights).to eq(['1'])
end
it 'autocorrects the offense' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(correct_source)
end
end
context 'send implicit arrays' do
let(:source) do
['a',
'.c = 1,',
'2, 3']
end
let(:correct_source) do
['a',
'.c = ',
'1,',
'2, 3'].join("\n")
end
it 'detects the offense' do
inspect_source(cop, source)
expect(cop.offenses.length).to eq(1)
expect(cop.offenses.first.line).to eq(2)
expect(cop.highlights).to eq(['1'])
end
it 'autocorrects the offense' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(correct_source)
end
end
it 'ignores properly formatted implicit arrays' do
inspect_source(
cop,
['a, b,',
'c =',
'1, 2,',
'3']
)
expect(cop.offenses).to be_empty
end
it 'ignores elements listed on a single line' do
inspect_source(
cop,
['b = [',
' :a,',
' :b]']
)
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/first_hash_element_line_break_spec.rb 0000664 0000000 0000000 00000004040 13070542236 0031034 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::FirstHashElementLineBreak do
subject(:cop) { described_class.new }
context 'elements listed on the first line' do
let(:source) do
['a = { a: 1,',
' b: 2}']
end
it 'detects the offense' do
inspect_source(cop, source)
expect(cop.offenses.length).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['a: 1'])
end
it 'autocorrects the offense' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(
"a = { \n" \
"a: 1,\n" \
' b: 2}'
)
end
end
context 'hash nested in a method call' do
let(:source) do
['method({ foo: 1,',
' bar: 2 })']
end
it 'detects the offense' do
inspect_source(cop, source)
expect(cop.offenses.length).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['foo: 1'])
end
it 'autocorrects the offense' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(
"method({ \n" \
"foo: 1,\n" \
' bar: 2 })'
)
end
end
it 'ignores implicit hashes in method calls with parens' do
inspect_source(
cop,
['method(',
' foo: 1,',
' bar: 2)']
)
expect(cop.offenses).to be_empty
end
it 'ignores implicit hashes in method calls without parens' do
inspect_source(
cop,
['method foo: 1,',
' bar:2']
)
expect(cop.offenses).to be_empty
end
it 'ignores implicit hashes in method calls that are improperly formatted' do
# These are covered by Style/FirstMethodArgumentLineBreak
inspect_source(
cop,
['method(foo: 1,',
' bar: 2)']
)
expect(cop.offenses).to be_empty
end
it 'ignores elements listed on a single line' do
inspect_source(
cop,
['b = {',
' a: 1,',
' b: 2}']
)
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/first_method_argument_line_break_spec.rb 0000664 0000000 0000000 00000004216 13070542236 0031567 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::FirstMethodArgumentLineBreak do
subject(:cop) { described_class.new }
context 'args listed on the first line' do
let(:source) do
['foo(bar,',
' baz)']
end
it 'detects the offense' do
inspect_source(cop, source)
expect(cop.offenses.length).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['bar'])
end
it 'autocorrects the offense' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(
"foo(\n" \
"bar,\n" \
' baz)'
)
end
end
context 'hash arg spanning multiple lines' do
let(:source) do
['something(3, bar: 1,',
'baz: 2)']
end
it 'detects the offense' do
inspect_source(cop, source)
expect(cop.offenses.length).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['3'])
end
it 'autocorrects the offense' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(
"something(\n" \
"3, bar: 1,\n" \
'baz: 2)'
)
end
end
context 'hash arg without a line break before the first pair' do
let(:source) do
['something(bar: 1,',
'baz: 2)']
end
it 'detects the offense' do
inspect_source(cop, source)
expect(cop.offenses.length).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['bar: 1'])
end
it 'autocorrects the offense' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(
"something(\n" \
"bar: 1,\n" \
'baz: 2)'
)
end
end
it 'ignores arguments listed on a single line' do
inspect_source(cop, 'foo(bar, baz, bing)')
expect(cop.offenses).to be_empty
end
it 'ignores arguments without parens' do
inspect_source(
cop,
['foo bar,',
' baz']
)
expect(cop.offenses).to be_empty
end
it 'ignores methods without arguments' do
inspect_source(cop, 'foo')
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/first_method_parameter_line_break_spec.rb 0000664 0000000 0000000 00000005303 13070542236 0031723 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::FirstMethodParameterLineBreak do
subject(:cop) { described_class.new }
context 'params listed on the first line' do
let(:source) do
['def foo(bar,',
' baz)',
' do_something',
'end']
end
it 'detects the offense' do
inspect_source(cop, source)
expect(cop.offenses.length).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['bar'])
end
it 'autocorrects the offense' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(
"def foo(\n" \
"bar,\n" \
" baz)\n" \
" do_something\n" \
'end'
)
end
end
context 'params on first line of singleton method' do
let(:source) do
['def self.foo(bar,',
' baz)',
' do_something',
'end']
end
it 'detects the offense' do
inspect_source(cop, source)
expect(cop.offenses.length).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['bar'])
end
it 'autocorrects the offense' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(
"def self.foo(\n" \
"bar,\n" \
" baz)\n" \
" do_something\n" \
'end'
)
end
end
it 'ignores params listed on a single line' do
inspect_source(
cop,
['def foo(bar, baz, bing)',
' do_something',
'end']
)
expect(cop.offenses).to be_empty
end
it 'ignores params without parens' do
inspect_source(
cop,
['def foo bar,',
' baz',
' do_something',
'end']
)
expect(cop.offenses).to be_empty
end
it 'ignores single-line methods' do
inspect_source(
cop,
'def foo(bar, baz) ; bing ; end'
)
expect(cop.offenses).to be_empty
end
it 'ignores methods without params' do
inspect_source(
cop,
['def foo',
' bing',
'end']
)
expect(cop.offenses).to be_empty
end
context 'params with default values' do
let(:source) do
['def foo(bar = [],',
' baz = 2)',
' do_something',
'end']
end
it 'detects the offense' do
inspect_source(cop, source)
expect(cop.offenses.length).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(['bar = []'])
end
it 'autocorrects the offense' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(
"def foo(\n" \
"bar = [],\n" \
" baz = 2)\n" \
" do_something\n" \
'end'
)
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/first_parameter_indentation_spec.rb 0000664 0000000 0000000 00000035073 13070542236 0030613 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::FirstParameterIndentation do
subject(:cop) { described_class.new(config) }
let(:config) do
RuboCop::Config
.new('Style/FirstParameterIndentation' => {
'EnforcedStyle' => style,
'SupportedStyles' =>
%w[consistent special_for_inner_method_call
special_for_inner_method_call_in_parentheses]
},
'Style/IndentationWidth' => { 'Width' => indentation_width })
end
shared_examples 'common behavior' do
context 'when IndentationWidth:Width is 2' do
let(:indentation_width) { 2 }
it 'registers an offense for an over-indented first parameter' do
inspect_source(cop, ['run(',
' :foo,',
' bar: 3',
')'])
expect(cop.messages).to eq(['Indent the first parameter one step ' \
'more than the start of the ' \
'previous line.'])
expect(cop.highlights).to eq([':foo'])
end
it 'registers an offense for an under-indented first parameter' do
inspect_source(cop, ['run(',
' :foo,',
' bar: 3',
')'])
expect(cop.highlights).to eq([':foo'])
end
it 'registers an offense on lines affected by another offense' do
inspect_source(cop, ['foo(',
' bar(',
' 7',
')',
')'])
expect(cop.highlights).to eq([['bar(',
' 7',
')'].join("\n"),
'7'])
expect(cop.messages)
.to eq(['Indent the first parameter one step more than ' \
'the start of the previous line.',
'Bad indentation of the first parameter.'])
end
it 'auto-corrects nested offenses' do
new_source = autocorrect_source(cop, ['foo(',
' bar(',
' 7',
')',
')'])
expect(new_source)
.to eq(['foo(',
' bar(',
' 7',
' )', # Will be corrected by IndentationConsistency.
')'].join("\n"))
end
context 'for assignment' do
it 'accepts a correctly indented first parameter and does not care ' \
'about the second parameter' do
inspect_source(cop, ['x = run(',
' :foo,',
' bar: 3',
')'])
expect(cop.offenses).to be_empty
end
context 'with line break' do
it 'accepts a correctly indented first parameter' do
inspect_source(cop, ['x =',
' run(',
' :foo)'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for an under-indented first parameter' do
inspect_source(cop, ['@x =',
' run(',
' :foo)'])
expect(cop.highlights).to eq([':foo'])
end
end
end
it 'accepts a first parameter that is not preceded by a line break' do
inspect_source(cop, ['run :foo,',
' bar: 3'])
expect(cop.offenses).to be_empty
end
context 'when the receiver contains a line break' do
it 'accepts a correctly indented first parameter' do
inspect_source(cop, ['puts x.',
' merge(',
' b: 2',
' )'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for an over-indented first parameter' do
inspect_source(cop, ['puts x.',
' merge(',
' b: 2',
' )'])
expect(cop.messages).to eq(['Indent the first parameter one step ' \
'more than the start of the ' \
'previous line.'])
expect(cop.highlights).to eq(['b: 2'])
end
it 'accepts a correctly indented first parameter preceded by an ' \
'empty line' do
inspect_source(cop, ['puts x.',
' merge(',
'',
' b: 2',
' )'])
expect(cop.offenses).to be_empty
end
context 'when preceded by a comment line' do
it 'accepts a correctly indented first parameter' do
inspect_source(cop, ['puts x.',
' merge( # EOL comment',
' # comment',
' b: 2',
' )'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for an under-indented first parameter' do
inspect_source(cop, ['puts x.',
' merge(',
' # comment',
' b: 2',
' )'])
expect(cop.messages).to eq(['Indent the first parameter one step ' \
'more than the start of the previous ' \
'line (not counting the comment).'])
expect(cop.highlights).to eq(['b: 2'])
end
end
end
it 'accepts method calls with no parameters' do
inspect_source(cop, ['run()',
'run_again'])
expect(cop.offenses).to be_empty
end
it 'accepts operator calls' do
inspect_source(cop, ['params = default_cfg.keys - %w(Description) -',
' cfg.keys'])
expect(cop.offenses).to be_empty
end
it 'does not view []= as an outer method call' do
inspect_source(cop, ['@subject_results[subject] = original.update(',
' mutation_results: (dup << mutation_result),',
' tests: test_result.tests',
')'])
expect(cop.offenses).to be_empty
end
it 'does not view chained call as an outer method call' do
inspect_source(cop, [' A = Regexp.union(',
' /[A-Za-z_][A-Za-z\d_]*[!?=]?/,',
' *AST::Types::OPERATOR_METHODS.map(&:to_s)',
' ).freeze'])
expect(cop.offenses).to be_empty
end
it 'auto-corrects an under-indented first parameter' do
new_source = autocorrect_source(cop, ['x =',
' run(',
' :foo,',
' bar: 3',
')'])
expect(new_source).to eq(['x =',
' run(',
' :foo,',
' bar: 3',
')'].join("\n"))
end
end
context 'when IndentationWidth:Width is 4' do
let(:indentation_width) { 4 }
it 'auto-corrects an over-indented first parameter' do
new_source = autocorrect_source(cop, ['run(',
' :foo,',
' bar: 3)'])
expect(new_source).to eq(['run(',
' :foo,',
' bar: 3)'].join("\n"))
end
end
context 'when indentation width is overridden for this cop only' do
let(:config) do
RuboCop::Config
.new('Style/FirstParameterIndentation' => {
'EnforcedStyle' => style,
'SupportedStyles' =>
%w[consistent special_for_inner_method_call
special_for_inner_method_call_in_parentheses],
'IndentationWidth' => 4
},
'Style/IndentationWidth' => { 'Width' => 2 })
end
it 'accepts a correctly indented first parameter' do
inspect_source(cop, ['run(',
' :foo,',
' bar: 3',
')'])
expect(cop.offenses).to be_empty
end
it 'auto-corrects an over-indented first parameter' do
new_source = autocorrect_source(cop, ['run(',
' :foo,',
' bar: 3)'])
expect(new_source).to eq(['run(',
' :foo,',
' bar: 3)'].join("\n"))
end
end
end
context 'when EnforcedStyle is special_for_inner_method_call' do
let(:style) { 'special_for_inner_method_call' }
let(:indentation_width) { 2 }
include_examples 'common behavior'
context 'for method calls within method calls' do
context 'with outer parentheses' do
it 'registers an offense for an over-indented first parameter' do
inspect_source(cop, ['run(:foo, defaults.merge(',
' bar: 3))'])
expect(cop.messages).to eq(['Indent the first parameter one step ' \
'more than `defaults.merge(`.'])
expect(cop.highlights).to eq(['bar: 3'])
end
end
context 'without outer parentheses' do
it 'accepts a first parameter with special indentation' do
inspect_source(cop, ['run :foo, defaults.merge(',
' bar: 3)'])
expect(cop.offenses).to be_empty
end
end
it 'auto-corrects an over-indented first parameter' do
new_source = autocorrect_source(cop,
['run(:foo, defaults.merge(',
' bar: 3))'])
expect(new_source).to eq(['run(:foo, defaults.merge(',
' bar: 3))'].join("\n"))
end
end
end
context 'when EnforcedStyle is ' \
'special_for_inner_method_call_in_parentheses' do
let(:style) { 'special_for_inner_method_call_in_parentheses' }
let(:indentation_width) { 2 }
include_examples 'common behavior'
context 'for method calls within method calls' do
context 'with outer parentheses' do
it 'registers an offense for an over-indented first parameter' do
inspect_source(cop, ['run(:foo, defaults.merge(',
' bar: 3))'])
expect(cop.messages).to eq(['Indent the first parameter one step ' \
'more than `defaults.merge(`.'])
expect(cop.highlights).to eq(['bar: 3'])
end
it 'registers an offense for an under-indented first parameter' do
inspect_source(cop, ['run(:foo, defaults.',
' merge(',
' bar: 3))'])
expect(cop.messages).to eq(['Indent the first parameter one step ' \
'more than the start of the ' \
'previous line.'])
expect(cop.highlights).to eq(['bar: 3'])
end
it 'accepts a correctly indented first parameter in interpolation' do
inspect_source(cop, ['puts %(',
' ',
' #{Array(',
' 42',
' )}',
'
',
')'])
expect(cop.offenses).to be_empty
end
it 'accepts a correctly indented first parameter with fullwidth ' \
'characters' do
inspect_source(cop, ["puts('Ｒｕｂｙ', f(",
' a))'])
expect(cop.offenses).to be_empty
end
end
context 'without outer parentheses' do
it 'accepts a first parameter with consistent style indentation' do
inspect_source(cop, ['run :foo, defaults.merge(',
' bar: 3)'])
expect(cop.offenses).to be_empty
end
end
it 'auto-corrects an over-indented first parameter' do
new_source = autocorrect_source(cop,
['run(:foo, defaults.merge(',
' bar: 3))'])
expect(new_source).to eq(['run(:foo, defaults.merge(',
' bar: 3))'].join("\n"))
end
end
end
context 'when EnforcedStyle is consistent' do
let(:style) { 'consistent' }
let(:indentation_width) { 2 }
include_examples 'common behavior'
context 'for method calls within method calls' do
it 'registers an offense for an over-indented first parameter' do
inspect_source(cop, ['run(:foo, defaults.merge(',
' bar: 3))'])
expect(cop.messages).to eq(['Indent the first parameter one step ' \
'more than the start of the ' \
'previous line.'])
expect(cop.highlights).to eq(['bar: 3'])
end
it 'accepts first parameter indented relative to previous line' do
inspect_source(cop,
[' @diagnostics.process(Diagnostic.new(',
' :error, :token, { :token => name }, location))'])
expect(cop.offenses).to be_empty
end
it 'auto-corrects an over-indented first parameter' do
new_source = autocorrect_source(cop,
['run(:foo, defaults.merge(',
' bar: 3))'])
expect(new_source).to eq(['run(:foo, defaults.merge(',
' bar: 3))'].join("\n"))
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/flip_flop_spec.rb 0000664 0000000 0000000 00000001232 13070542236 0024770 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::FlipFlop do
subject(:cop) { described_class.new }
it 'registers an offense for inclusive flip flops' do
inspect_source(cop,
['DATA.each_line do |line|',
'print line if (line =~ /begin/)..(line =~ /end/)',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for exclusive flip flops' do
inspect_source(cop,
['DATA.each_line do |line|',
'print line if (line =~ /begin/)...(line =~ /end/)',
'end'])
expect(cop.offenses.size).to eq(1)
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/for_spec.rb 0000664 0000000 0000000 00000006377 13070542236 0023623 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::For, :config do
subject(:cop) { described_class.new(config) }
context 'when each is the enforced style' do
let(:cop_config) { { 'EnforcedStyle' => 'each' } }
it 'registers an offense for for' do
inspect_source(cop,
['def func',
' for n in [1, 2, 3] do',
' puts n',
' end',
'end'])
expect(cop.messages).to eq(['Prefer `each` over `for`.'])
expect(cop.highlights).to eq(['for'])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'for')
end
it 'registers an offense for opposite + correct style' do
inspect_source(cop,
['def func',
' for n in [1, 2, 3] do',
' puts n',
' end',
' [1, 2, 3].each do |n|',
' puts n',
' end',
'end'])
expect(cop.messages).to eq(['Prefer `each` over `for`.'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'accepts multiline each' do
inspect_source(cop,
['def func',
' [1, 2, 3].each do |n|',
' puts n',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts :for' do
inspect_source(cop, '[:for, :ala, :bala]')
expect(cop.offenses).to be_empty
end
it 'accepts def for' do
inspect_source(cop, 'def for; end')
expect(cop.offenses).to be_empty
end
end
context 'when for is the enforced style' do
let(:cop_config) { { 'EnforcedStyle' => 'for' } }
it 'accepts for' do
inspect_source(cop,
['def func',
' for n in [1, 2, 3] do',
' puts n',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for multiline each' do
inspect_source(cop,
['def func',
' [1, 2, 3].each do |n|',
' puts n',
' end',
'end'])
expect(cop.messages).to eq(['Prefer `for` over `each`.'])
expect(cop.highlights).to eq(['each'])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'each')
end
it 'registers an offense for correct + opposite style' do
inspect_source(cop,
['def func',
' for n in [1, 2, 3] do',
' puts n',
' end',
' [1, 2, 3].each do |n|',
' puts n',
' end',
'end'])
expect(cop.messages).to eq(['Prefer `for` over `each`.'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'accepts single line each' do
inspect_source(cop,
['def func',
' [1, 2, 3].each { |n| puts n }',
'end'])
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/format_string_spec.rb 0000664 0000000 0000000 00000013175 13070542236 0025705 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::FormatString, :config do
subject(:cop) { described_class.new(config) }
context 'when enforced style is sprintf' do
let(:cop_config) { { 'EnforcedStyle' => 'sprintf' } }
it 'registers an offense for a string followed by something' do
inspect_source(cop,
'puts "%d" % 10')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Favor `sprintf` over `String#%`.'])
end
it 'registers an offense for something followed by an array' do
inspect_source(cop,
'puts x % [10, 11]')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Favor `sprintf` over `String#%`.'])
end
it 'does not register an offense for numbers' do
inspect_source(cop,
'puts 10 % 4')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for ambiguous cases' do
inspect_source(cop,
'puts x % 4')
expect(cop.offenses).to be_empty
inspect_source(cop,
'puts x % Y')
expect(cop.offenses).to be_empty
end
it 'works if the first operand contains embedded expressions' do
inspect_source(cop,
'puts "#{x * 5} %d #{@test}" % 10')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Favor `sprintf` over `String#%`.'])
end
it 'registers an offense for format' do
inspect_source(cop,
'format(something, a, b)')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Favor `sprintf` over `format`.'])
end
it 'registers an offense for format with 2 arguments' do
inspect_source(cop,
'format("%X", 123)')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Favor `sprintf` over `format`.'])
end
end
context 'when enforced style is format' do
let(:cop_config) { { 'EnforcedStyle' => 'format' } }
it 'registers an offense for a string followed by something' do
inspect_source(cop,
'puts "%d" % 10')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Favor `format` over `String#%`.'])
end
it 'registers an offense for something followed by an array' do
inspect_source(cop,
'puts x % [10, 11]')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Favor `format` over `String#%`.'])
end
it 'registers an offense for something followed by a hash' do
inspect_source(cop,
'puts x % { a: 10, b: 11 }')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Favor `format` over `String#%`.'])
end
it 'does not register an offense for numbers' do
inspect_source(cop,
'puts 10 % 4')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for ambiguous cases' do
inspect_source(cop,
'puts x % 4')
expect(cop.offenses).to be_empty
inspect_source(cop,
'puts x % Y')
expect(cop.offenses).to be_empty
end
it 'works if the first operand contains embedded expressions' do
inspect_source(cop,
'puts "#{x * 5} %d #{@test}" % 10')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Favor `format` over `String#%`.'])
end
it 'registers an offense for sprintf' do
inspect_source(cop,
'sprintf(something, a, b)')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Favor `format` over `sprintf`.'])
end
it 'registers an offense for sprintf with 2 arguments' do
inspect_source(cop,
"sprintf('%020d', 123)")
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Favor `format` over `sprintf`.'])
end
end
context 'when enforced style is percent' do
let(:cop_config) { { 'EnforcedStyle' => 'percent' } }
it 'registers an offense for format' do
inspect_source(cop,
'format(something, a, b)')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Favor `String#%` over `format`.'])
end
it 'registers an offense for sprintf' do
inspect_source(cop,
'sprintf(something, a, b)')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Favor `String#%` over `sprintf`.'])
end
it 'registers an offense for sprintf with 3 arguments' do
inspect_source(cop,
'format("%d %04x", 123, 123)')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Favor `String#%` over `format`.'])
end
it 'accepts format with 1 argument' do
inspect_source(cop,
'format :xml')
expect(cop.offenses).to be_empty
end
it 'accepts sprintf with 1 argument' do
inspect_source(cop,
'sprintf :xml')
expect(cop.offenses).to be_empty
end
it 'accepts format without arguments' do
inspect_source(cop,
'format')
expect(cop.offenses).to be_empty
end
it 'accepts sprintf without arguments' do
inspect_source(cop,
'sprintf')
expect(cop.offenses).to be_empty
end
it 'accepts String#%' do
inspect_source(cop,
'puts "%d" % 10')
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/frozen_string_literal_comment_spec.rb 0000664 0000000 0000000 00000052253 13070542236 0031156 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::FrozenStringLiteralComment, :config do
subject(:cop) { described_class.new(config) }
context 'always' do
let(:cop_config) do
{ 'Enabled' => true,
'EnforcedStyle' => 'always' }
end
it 'accepts an empty source' do
inspect_source(cop, '')
expect(cop.offenses).to be_empty
end
it 'accepts a source with no tokens' do
inspect_source(cop, ' ')
expect(cop.offenses).to be_empty
end
it 'accepts a frozen string literal on the top line' do
inspect_source(cop, ['# frozen_string_literal: true',
'puts 1'])
expect(cop.offenses).to be_empty
end
it 'accepts a disabled frozen string literal on the top line' do
inspect_source(cop, ['# frozen_string_literal: false',
'puts 1'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for not having a frozen string literal comment ' \
'on the top line' do
inspect_source(cop, 'puts 1')
expect(cop.messages)
.to eq(['Missing magic comment `# frozen_string_literal: true`.'])
end
it 'registers an offense for not having a frozen string literal comment ' \
'under a shebang' do
inspect_source(cop, ['#!/usr/bin/env ruby',
'puts 1'])
expect(cop.messages)
.to eq(['Missing magic comment `# frozen_string_literal: true`.'])
end
it 'accepts a frozen string literal below a shebang comment' do
inspect_source(cop, ['#!/usr/bin/env ruby',
'# frozen_string_literal: true',
'puts 1'])
expect(cop.offenses).to be_empty
end
it 'accepts a disabled frozen string literal below a shebang comment' do
inspect_source(cop, ['#!/usr/bin/env ruby',
'# frozen_string_literal: false',
'puts 1'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for not having a frozen string literal comment ' \
'under an encoding comment' do
inspect_source(cop, ['# encoding: utf-8',
'puts 1'])
expect(cop.messages)
.to eq(['Missing magic comment `# frozen_string_literal: true`.'])
end
it 'accepts a frozen string literal below an encoding comment' do
inspect_source(cop, ['# encoding: utf-8',
'# frozen_string_literal: true',
'puts 1'])
expect(cop.offenses).to be_empty
end
it 'accepts a dsabled frozen string literal below an encoding comment' do
inspect_source(cop, ['# encoding: utf-8',
'# frozen_string_literal: false',
'puts 1'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for not having a frozen string literal comment ' \
'under a shebang and an encoding comment' do
inspect_source(cop, ['#!/usr/bin/env ruby',
'# encoding: utf-8',
'puts 1'])
expect(cop.messages)
.to eq(['Missing magic comment `# frozen_string_literal: true`.'])
end
it 'accepts a frozen string literal comment below shebang and encoding ' \
'comments' do
inspect_source(cop, ['#!/usr/bin/env ruby',
'# encoding: utf-8',
'# frozen_string_literal: true',
'puts 1'])
expect(cop.offenses).to be_empty
end
it 'accepts a disabled frozen string literal comment below shebang and ' \
'encoding comments' do
inspect_source(cop, ['#!/usr/bin/env ruby',
'# encoding: utf-8',
'# frozen_string_literal: false',
'puts 1'])
expect(cop.offenses).to be_empty
end
it 'accepts a frozen string literal comment below shebang above an ' \
'encoding comments' do
inspect_source(cop, ['#!/usr/bin/env ruby',
'# frozen_string_literal: true',
'# encoding: utf-8',
'puts 1'])
expect(cop.offenses).to be_empty
end
it 'accepts a disabled frozen string literal comment below shebang above ' \
'an encoding comments' do
inspect_source(cop, ['#!/usr/bin/env ruby',
'# frozen_string_literal: false',
'# encoding: utf-8',
'puts 1'])
expect(cop.offenses).to be_empty
end
it 'accepts an emacs style combined magic comment' do
inspect_source(
cop,
[
'#!/usr/bin/env ruby',
'# -*- encoding: UTF-8; frozen_string_literal: true -*-',
'# encoding: utf-8',
'puts 1'
]
)
expect(cop.offenses).to be_empty
end
context 'auto-correct' do
it 'adds a frozen string literal comment to the first line if one is ' \
'missing' do
new_source = autocorrect_source(cop, 'puts 1')
expect(new_source).to eq(['# frozen_string_literal: true',
'puts 1'].join("\n"))
end
it 'adds a frozen string literal comment after a shebang' do
new_source = autocorrect_source(cop, ['#!/usr/bin/env ruby',
'puts 1'])
expect(new_source).to eq(['#!/usr/bin/env ruby',
'# frozen_string_literal: true',
'puts 1'].join("\n"))
end
it 'adds a frozen string literal comment after an encoding comment' do
new_source = autocorrect_source(cop, ['# encoding: utf-8',
'puts 1'])
expect(new_source).to eq(['# encoding: utf-8',
'# frozen_string_literal: true',
'puts 1'].join("\n"))
end
it 'adds a frozen string literal comment after a shebang and encoding ' \
'comment' do
new_source = autocorrect_source(cop, ['#!/usr/bin/env ruby',
'# encoding: utf-8',
'puts 1'])
expect(new_source).to eq(['#!/usr/bin/env ruby',
'# encoding: utf-8',
'# frozen_string_literal: true',
'puts 1'].join("\n"))
end
it 'adds a frozen string literal comment after a shebang and encoding ' \
'comment when there is an empty line before the code' do
new_source = autocorrect_source(cop, ['#!/usr/bin/env ruby',
'# encoding: utf-8',
'',
'puts 1'])
expect(new_source).to eq(['#!/usr/bin/env ruby',
'# encoding: utf-8',
'# frozen_string_literal: true',
'',
'puts 1'].join("\n"))
end
it 'adds a frozen string literal comment after an encoding comment ' \
'when there is an empty line before the code' do
new_source = autocorrect_source(cop, ['# encoding: utf-8',
'',
'puts 1'])
expect(new_source).to eq(['# encoding: utf-8',
'# frozen_string_literal: true',
'',
'puts 1'].join("\n"))
end
end
end
context 'when_needed' do
let(:cop_config) do
{ 'Enabled' => true,
'EnforcedStyle' => 'when_needed' }
end
it 'accepts an empty source' do
inspect_source(cop, '')
expect(cop.offenses).to be_empty
end
if RUBY_VERSION >= '2.3.0'
context 'ruby >= 2.3' do
context 'no frozen string literal comment' do
it 'accepts not modifing a string' do
inspect_source(cop, 'puts "x"')
expect(cop.offenses).to be_empty
end
it 'accepts calling + on a string' do
inspect_source(cop, '"x" + "y"')
expect(cop.offenses).to be_empty
end
it 'accepts calling freeze on a variable' do
inspect_source(cop, ['foo = "x"',
' foo.freeze'])
expect(cop.offenses).to be_empty
end
it 'accepts calling shovel on a variable' do
inspect_source(cop, ['foo = "x"',
' foo << "y"'])
expect(cop.offenses).to be_empty
end
it 'accepts freezing a string' do
inspect_source(cop, '"x".freeze')
expect(cop.offenses).to be_empty
end
it 'accepts when << is called on a string literal' do
inspect_source(cop, '"x" << "y"')
expect(cop.offenses).to be_empty
end
end
it 'accepts freezing a string when there is a frozen string literal ' \
'comment' do
inspect_source(cop, ['# frozen_string_literal: true',
'"x".freeze'])
expect(cop.offenses).to be_empty
end
it 'accepts shoveling into a string when there is a frozen string ' \
'literal comment' do
inspect_source(cop, ['# frozen_string_literal: true',
'"x" << "y"'])
expect(cop.offenses).to be_empty
end
end
end
context 'ruby < 2.3' do
context 'target_ruby_version < 2.3', :ruby19 do
it 'accepts freezing a string' do
inspect_source(cop, '"x".freeze')
expect(cop.offenses).to be_empty
end
it 'accepts calling << on a string' do
inspect_source(cop, '"x" << "y"')
expect(cop.offenses).to be_empty
end
it 'accepts freezing a string with interpolation' do
inspect_source(cop, '"#{foo}bar".freeze')
expect(cop.offenses).to be_empty
end
it 'accepts calling << on a string with interpolation' do
inspect_source(cop, '"#{foo}bar" << "baz"')
expect(cop.offenses).to be_empty
end
end
context 'target_ruby_version 2.3+', :ruby23 do
it 'accepts freezing a string' do
inspect_source(cop, '"x".freeze')
expect(cop.messages)
.to eq(['Missing magic comment `# frozen_string_literal: true`.'])
end
it 'accepts calling << on a string' do
inspect_source(cop, '"x" << "y"')
expect(cop.messages)
.to eq(['Missing magic comment `# frozen_string_literal: true`.'])
end
it 'accepts freezing a string with interpolation' do
inspect_source(cop, '"#{foo}bar".freeze')
expect(cop.messages)
.to eq(['Missing magic comment `# frozen_string_literal: true`.'])
end
it 'accepts calling << on a string with interpolation' do
inspect_source(cop, '"#{foo}bar" << "baz"')
expect(cop.messages)
.to eq(['Missing magic comment `# frozen_string_literal: true`.'])
end
end
end
end
context 'never' do
let(:cop_config) do
{ 'Enabled' => true,
'EnforcedStyle' => 'never' }
end
it 'accepts an empty source' do
inspect_source(cop, '')
expect(cop.offenses).to be_empty
end
it 'accepts a source with no tokens' do
inspect_source(cop, ' ')
expect(cop.offenses).to be_empty
end
it 'registers an offense for a frozen string literal comment ' \
'on the top line' do
inspect_source(cop, ['# frozen_string_literal: true',
'puts 1'])
expect(cop.messages).to eq(['Unnecessary frozen string literal comment.'])
expect(cop.highlights).to eq(['# frozen_string_literal: true'])
end
it 'registers an offense for a disabled frozen string literal comment ' \
'on the top line' do
inspect_source(cop, ['# frozen_string_literal: false',
'puts 1'])
expect(cop.messages).to eq(['Unnecessary frozen string literal comment.'])
expect(cop.highlights).to eq(['# frozen_string_literal: false'])
end
it 'accepts not having a frozen string literal comment on the top line' do
inspect_source(cop, 'puts 1')
expect(cop.offenses).to be_empty
end
it 'accepts not having not having a frozen string literal comment ' \
'under a shebang' do
inspect_source(cop, ['#!/usr/bin/env ruby',
'puts 1'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for a frozen string literal comment ' \
'below a shebang comment' do
inspect_source(cop, ['#!/usr/bin/env ruby',
'# frozen_string_literal: true',
'puts 1'])
expect(cop.messages).to eq(['Unnecessary frozen string literal comment.'])
expect(cop.highlights).to eq(['# frozen_string_literal: true'])
end
it 'registers an offense for a disabled frozen string literal ' \
'below a shebang comment' do
inspect_source(cop, ['#!/usr/bin/env ruby',
'# frozen_string_literal: false',
'puts 1'])
expect(cop.messages).to eq(['Unnecessary frozen string literal comment.'])
expect(cop.highlights).to eq(['# frozen_string_literal: false'])
end
it 'allows not having a frozen string literal comment ' \
'under an encoding comment' do
inspect_source(cop, ['# encoding: utf-8',
'puts 1'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for a frozen string literal comment below ' \
'an encoding comment' do
inspect_source(cop, ['# encoding: utf-8',
'# frozen_string_literal: true',
'puts 1'])
expect(cop.messages).to eq(['Unnecessary frozen string literal comment.'])
expect(cop.highlights).to eq(['# frozen_string_literal: true'])
end
it 'registers an offense for a dsabled frozen string literal below ' \
'an encoding comment' do
inspect_source(cop, ['# encoding: utf-8',
'# frozen_string_literal: false',
'puts 1'])
expect(cop.messages).to eq(['Unnecessary frozen string literal comment.'])
expect(cop.highlights).to eq(['# frozen_string_literal: false'])
end
it 'allows not having a frozen string literal comment ' \
'under a shebang and an encoding comment' do
inspect_source(cop, ['#!/usr/bin/env ruby',
'# encoding: utf-8',
'puts 1'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for a frozen string literal comment ' \
'below shebang and encoding comments' do
inspect_source(cop, ['#!/usr/bin/env ruby',
'# encoding: utf-8',
'# frozen_string_literal: true',
'puts 1'])
expect(cop.messages).to eq(['Unnecessary frozen string literal comment.'])
expect(cop.highlights).to eq(['# frozen_string_literal: true'])
end
it 'registers an offense for a disabled frozen string literal comment ' \
'below shebang and encoding comments' do
inspect_source(cop, ['#!/usr/bin/env ruby',
'# encoding: utf-8',
'# frozen_string_literal: false',
'puts 1'])
expect(cop.messages).to eq(['Unnecessary frozen string literal comment.'])
expect(cop.highlights).to eq(['# frozen_string_literal: false'])
end
it 'registers an offense for a frozen string literal comment ' \
'below shebang above an encoding comments' do
inspect_source(cop, ['#!/usr/bin/env ruby',
'# frozen_string_literal: true',
'# encoding: utf-8',
'puts 1'])
expect(cop.messages).to eq(['Unnecessary frozen string literal comment.'])
expect(cop.highlights).to eq(['# frozen_string_literal: true'])
end
it 'registers an offense for a disabled frozen string literal comment ' \
'below shebang above an encoding comments' do
inspect_source(cop, ['#!/usr/bin/env ruby',
'# frozen_string_literal: false',
'# encoding: utf-8',
'puts 1'])
expect(cop.messages).to eq(['Unnecessary frozen string literal comment.'])
expect(cop.highlights).to eq(['# frozen_string_literal: false'])
end
context 'auto-correct' do
it 'removes the frozen string literal comment from the top line' do
new_source = autocorrect_source(cop, ['# frozen_string_literal: true',
'puts 1'])
expect(new_source).to eq('puts 1')
end
it 'removes a disabled frozen string literal comment on the top line' do
new_source = autocorrect_source(cop, ['# frozen_string_literal: false',
'puts 1'])
expect(new_source).to eq('puts 1')
end
it 'removes a frozen string literal comment below a shebang comment' do
new_source = autocorrect_source(cop, ['#!/usr/bin/env ruby',
'# frozen_string_literal: true',
'puts 1'])
expect(new_source).to eq(['#!/usr/bin/env ruby',
'puts 1'].join("\n"))
end
it 'removes a disabled frozen string literal below a shebang comment' do
new_source = autocorrect_source(cop, ['#!/usr/bin/env ruby',
'# frozen_string_literal: false',
'puts 1'])
expect(new_source).to eq(['#!/usr/bin/env ruby',
'puts 1'].join("\n"))
end
it 'removes a frozen string literal comment below an encoding comment' do
new_source = autocorrect_source(cop, ['# encoding: utf-8',
'# frozen_string_literal: true',
'puts 1'])
expect(new_source).to eq(['# encoding: utf-8',
'puts 1'].join("\n"))
end
it 'removes a dsabled frozen string literal below an encoding comment' do
new_source = autocorrect_source(cop, ['# encoding: utf-8',
'# frozen_string_literal: false',
'puts 1'])
expect(new_source).to eq(['# encoding: utf-8',
'puts 1'].join("\n"))
end
it 'removes a frozen string literal comment ' \
'below shebang and encoding comments' do
new_source = autocorrect_source(cop, ['#!/usr/bin/env ruby',
'# encoding: utf-8',
'# frozen_string_literal: true',
'puts 1'])
expect(new_source).to eq(['#!/usr/bin/env ruby',
'# encoding: utf-8',
'puts 1'].join("\n"))
end
it 'removes a disabled frozen string literal comment from ' \
'below shebang and encoding comments' do
new_source = autocorrect_source(cop, ['#!/usr/bin/env ruby',
'# encoding: utf-8',
'# frozen_string_literal: false',
'puts 1'])
expect(new_source).to eq(['#!/usr/bin/env ruby',
'# encoding: utf-8',
'puts 1'].join("\n"))
end
it 'removes a frozen string literal comment ' \
'below shebang above an encoding comments' do
new_source = autocorrect_source(cop, ['#!/usr/bin/env ruby',
'# frozen_string_literal: true',
'# encoding: utf-8',
'puts 1'])
expect(new_source).to eq(['#!/usr/bin/env ruby',
'# encoding: utf-8',
'puts 1'].join("\n"))
end
it 'removes a disabled frozen string literal comment ' \
'below shebang above an encoding comments' do
new_source = autocorrect_source(cop, ['#!/usr/bin/env ruby',
'# frozen_string_literal: false',
'# encoding: utf-8',
'puts 1'])
expect(new_source).to eq(['#!/usr/bin/env ruby',
'# encoding: utf-8',
'puts 1'].join("\n"))
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/global_vars_spec.rb 0000664 0000000 0000000 00000001510 13070542236 0025310 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::GlobalVars, :config do
cop_config = {
'AllowedVariables' => ['$allowed']
}
subject(:cop) { described_class.new(config) }
let(:cop_config) { cop_config }
it 'registers an offense for $custom' do
inspect_source(cop, 'puts $custom')
expect(cop.offenses.size).to eq(1)
end
it 'allows user whitelisted variables' do
inspect_source(cop, 'puts $allowed')
expect(cop.offenses).to be_empty
end
described_class::BUILT_IN_VARS.each do |var|
it "does not register an offense for built-in variable #{var}" do
inspect_source(cop, "puts #{var}")
expect(cop.offenses).to be_empty
end
end
it 'does not register an offense for backrefs like $1' do
inspect_source(cop, 'puts $1')
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/guard_clause_spec.rb 0000664 0000000 0000000 00000025556 13070542236 0025473 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::GuardClause, :config do
let(:cop) { described_class.new(config) }
let(:cop_config) { {} }
shared_examples 'reports offense' do |body|
it 'reports an offense if method body is if / unless without else' do
inspect_source(cop,
['def func',
' if something',
" #{body}",
' end',
'end',
'',
'def func',
' unless something',
" #{body}",
' end',
'end'])
expect(cop.offenses.size).to eq(2)
expect(cop.offenses.map(&:line).sort).to eq([2, 8])
expect(cop.messages)
.to eq(['Use a guard clause instead of wrapping ' \
'the code inside a conditional expression.'] * 2)
expect(cop.highlights).to eq(%w[if unless])
end
it 'reports an offense if method body is if / unless without else' do
inspect_source(cop,
['def func',
' if something',
" #{body}",
' end',
'end',
'',
'def func',
' unless something',
" #{body}",
' end',
'end'])
expect(cop.offenses.size).to eq(2)
expect(cop.offenses.map(&:line).sort).to eq([2, 8])
expect(cop.messages)
.to eq(['Use a guard clause instead of wrapping ' \
'the code inside a conditional expression.'] * 2)
expect(cop.highlights).to eq(%w[if unless])
end
it 'reports an offense if method body ends with if / unless without else' do
inspect_source(cop,
['def func',
' test',
' if something',
" #{body}",
' end',
'end',
'',
'def func',
' test',
' unless something',
" #{body}",
' end',
'end'])
expect(cop.offenses.size).to eq(2)
expect(cop.offenses.map(&:line).sort).to eq([3, 10])
expect(cop.messages)
.to eq(['Use a guard clause instead of wrapping ' \
'the code inside a conditional expression.'] * 2)
expect(cop.highlights).to eq(%w[if unless])
end
end
it_behaves_like('reports offense', 'work')
it_behaves_like('reports offense', '# TODO')
it 'does not report an offense if body is if..elsif..end' do
inspect_source(cop,
['def func',
' if something',
' a',
' elsif something_else',
' b',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it "doesn't report an offense if condition has multiple lines" do
inspect_source(cop,
['def func',
' if something &&',
' something_else',
' work',
' end',
'end',
'',
'def func',
' unless something &&',
' something_else',
' work',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts a method which body is if / unless with else' do
inspect_source(cop,
['def func',
' if something',
' work',
' else',
' test',
' end',
'end',
'',
'def func',
' unless something',
' work',
' else',
' test',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts a method which body does not end with if / unless' do
inspect_source(cop,
['def func',
' if something',
' work',
' end',
' test',
'end',
'',
'def func',
' unless something',
' work',
' end',
' test',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts a method whose body is a modifier if / unless' do
inspect_source(cop,
['def func',
' work if something',
'end',
'',
'def func',
' work if something',
'end'])
expect(cop.offenses).to be_empty
end
context 'MinBodyLength: 1' do
let(:cop_config) do
{ 'MinBodyLength' => 1 }
end
it 'reports an offense for if whose body has 1 line' do
inspect_source(cop,
['def func',
' if something',
' work',
' end',
'end',
'',
'def func',
' unless something',
' work',
' end',
'end'])
expect(cop.offenses.size).to eq(2)
expect(cop.offenses.map(&:line).sort).to eq([2, 8])
expect(cop.messages)
.to eq(['Use a guard clause instead of wrapping ' \
'the code inside a conditional expression.'] * 2)
expect(cop.highlights).to eq(%w[if unless])
end
end
context 'MinBodyLength: 4' do
let(:cop_config) do
{ 'MinBodyLength' => 4 }
end
it 'accepts a method whose body has 3 lines' do
inspect_source(cop,
['def func',
' if something',
' work',
' work',
' work',
' end',
'end',
'',
'def func',
' unless something',
' work',
' work',
' work',
' end',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'Invalid MinBodyLength' do
let(:cop_config) do
{ 'MinBodyLength' => -2 }
end
it 'fails with an error' do
source = ['def func',
' if something',
' work',
' end',
'end']
expect { inspect_source(cop, source) }
.to raise_error('MinBodyLength needs to be a positive integer!')
end
end
shared_examples 'on if nodes which exit current scope' do |kw|
it "registers an error with #{kw} in the if branch" do
inspect_source(cop, ['if something',
" #{kw}",
'else',
' puts "hello"',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Use a guard clause instead of wrapping ' \
'the code inside a conditional expression.'])
end
it "registers an error with #{kw} in the else branch" do
inspect_source(cop, ['if something',
' puts "hello"',
'else',
" #{kw}",
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Use a guard clause instead of wrapping ' \
'the code inside a conditional expression.'])
end
it "doesn't register an error if condition has multiple lines" do
inspect_source(cop, ['if something &&',
' something_else',
" #{kw}",
'else',
' puts "hello"',
'end'])
expect(cop.offenses).to be_empty
end
it "does not report an offense if #{kw} is inside elsif" do
inspect_source(cop,
['if something',
' a',
'elsif something_else',
" #{kw}",
'end'])
expect(cop.offenses).to be_empty
end
it "does not report an offense if #{kw} is inside if..elsif..else..end" do
inspect_source(cop,
['if something',
' a',
'elsif something_else',
' b',
'else',
" #{kw}",
'end'])
expect(cop.offenses).to be_empty
end
it "doesn't register an error if control flow expr has multiple lines" do
inspect_source(cop, ['if something',
" #{kw} 'blah blah blah' \\",
" 'blah blah blah'",
'else',
' puts "hello"',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an error if non-control-flow branch has multiple lines' do
inspect_source(cop, ['if something',
" #{kw}",
'else',
' puts "hello" \\',
' "blah blah blah"',
'end'])
expect(cop.offenses.size).to eq(1)
end
end
include_examples('on if nodes which exit current scope', 'return')
include_examples('on if nodes which exit current scope', 'next')
include_examples('on if nodes which exit current scope', 'break')
include_examples('on if nodes which exit current scope', 'raise "error"')
context 'method in module' do
it 'registers an offense for instance method' do
inspect_source(cop, ['module CopTest',
' def test',
' if something',
' work',
' end',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for singleton methods' do
inspect_source(cop, ['module CopTest',
' def self.test',
' if something',
' work',
' end',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/hash_syntax_spec.rb 0000664 0000000 0000000 00000060031 13070542236 0025351 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::HashSyntax, :config do
subject(:cop) { described_class.new(config) }
context 'configured to enforce ruby19 style' do
context 'with SpaceAroundOperators enabled' do
let(:config) do
RuboCop::Config.new('AllCops' => {
'TargetRubyVersion' => ruby_version
},
'Style/HashSyntax' => cop_config,
'Style/SpaceAroundOperators' => {
'Enabled' => true
})
end
let(:cop_config) do
{
'EnforcedStyle' => 'ruby19',
'SupportedStyles' => %w[ruby19 hash_rockets],
'UseHashRocketsWithSymbolValues' => false,
'PreferHashRocketsForNonAlnumEndingSymbols' => false
}.merge(cop_config_overrides)
end
let(:cop_config_overrides) { {} }
it 'registers offense for hash rocket syntax when new is possible' do
inspect_source(cop, 'x = { :a => 0 }')
expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
expect(cop.config_to_allow_offenses)
.to eq('EnforcedStyle' => 'hash_rockets')
end
it 'registers an offense for mixed syntax when new is possible' do
inspect_source(cop, 'x = { :a => 0, b: 1 }')
expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'registers an offense for hash rockets in method calls' do
inspect_source(cop, 'func(3, :a => 0)')
expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
end
it 'accepts hash rockets when keys have different types' do
inspect_source(cop, 'x = { :a => 0, "b" => 1 }')
expect(cop.messages).to be_empty
end
it 'accepts an empty hash' do
inspect_source(cop, '{}')
expect(cop.messages).to be_empty
end
context 'ruby < 2.2', :ruby21 do
it 'accepts hash rockets when symbol keys have string in them' do
inspect_source(cop, 'x = { :"string" => 0 }')
expect(cop.messages).to be_empty
end
end
context 'ruby >= 2.2', :ruby22 do
it 'registers an offense when symbol keys have strings in them' do
inspect_source(cop, 'x = { :"string" => 0 }')
expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
end
end
context 'if PreferHashRocketsForNonAlnumEndingSymbols is false' do
it 'registers an offense for hash rockets when symbols end with ?' do
inspect_source(cop, 'x = { :a? => 0 }')
expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
end
it 'registers an offense for hash rockets when symbols end with !' do
inspect_source(cop, 'x = { :a! => 0 }')
expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
end
end
context 'if PreferHashRocketsForNonAlnumEndingSymbols is true' do
let(:cop_config_overrides) do
{
'PreferHashRocketsForNonAlnumEndingSymbols' => true
}
end
it 'accepts hash rockets when symbols end with ?' do
inspect_source(cop, 'x = { :a? => 0 }')
expect(cop.messages).to be_empty
end
it 'accepts hash rockets when symbols end with !' do
inspect_source(cop, 'x = { :a! => 0 }')
expect(cop.messages).to be_empty
end
end
it 'accepts hash rockets when symbol keys end with =' do
inspect_source(cop, 'x = { :a= => 0 }')
expect(cop.messages).to be_empty
end
it 'accepts hash rockets when symbol characters are not supported' do
inspect_source(cop, 'x = { :[] => 0 }')
expect(cop.messages).to be_empty
end
it 'registers offense when keys start with an uppercase letter' do
inspect_source(cop, 'x = { :A => 0 }')
expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
end
it 'accepts new syntax in a hash literal' do
inspect_source(cop, 'x = { a: 0, b: 1 }')
expect(cop.messages).to be_empty
end
it 'accepts new syntax in method calls' do
inspect_source(cop, 'func(3, a: 0)')
expect(cop.messages).to be_empty
end
it 'auto-corrects old to new style' do
new_source = autocorrect_source(cop, '{ :a => 1, :b => 2}')
expect(new_source).to eq('{ a: 1, b: 2}')
end
it 'auto-corrects even if it interferes with SpaceAroundOperators' do
# Clobbering caused by two cops changing in the same range is dealt with
# by the auto-correct loop, so there's no reason to avoid a change.
new_source = autocorrect_source(cop, '{ :a=>1, :b=>2 }')
expect(new_source).to eq('{ a: 1, b: 2 }')
end
end
context 'with SpaceAroundOperators disabled' do
let(:config) do
RuboCop::Config.new('AllCops' => {
'TargetRubyVersion' => ruby_version
},
'Style/HashSyntax' => {
'EnforcedStyle' => 'ruby19',
'SupportedStyles' => %w[ruby19 hash_rockets],
'UseHashRocketsWithSymbolValues' => false
},
'Style/SpaceAroundOperators' => {
'Enabled' => false
})
end
it 'auto-corrects even if there is no space around =>' do
new_source = autocorrect_source(cop, '{ :a=>1, :b=>2 }')
expect(new_source).to eq('{ a: 1, b: 2 }')
end
end
context 'configured to use hash rockets when symbol values are found' do
let(:config) do
RuboCop::Config.new('Style/HashSyntax' => {
'EnforcedStyle' => 'ruby19',
'SupportedStyles' => %w[ruby19 hash_rockets],
'UseHashRocketsWithSymbolValues' => true
})
end
it 'accepts ruby19 syntax when no elements have symbol values' do
inspect_source(cop, 'x = { a: 1, b: 2 }')
expect(cop.messages).to be_empty
end
it 'accepts ruby19 syntax when no elements have symbol values ' \
'in method calls' do
inspect_source(cop, 'func(3, a: 0)')
expect(cop.messages).to be_empty
end
it 'accepts new syntax in method calls' do
inspect_source(cop, 'func(3, a: 0)')
expect(cop.messages).to be_empty
end
it 'accepts an empty hash' do
inspect_source(cop, '{}')
expect(cop.messages).to be_empty
end
it 'registers an offense when any element uses a symbol for the value' do
inspect_source(cop, 'x = { a: 1, b: :c }')
expect(cop.messages)
.to eq(['Use hash rockets syntax.', 'Use hash rockets syntax.'])
end
it 'registers an offense when any element has a symbol value ' \
'in method calls' do
inspect_source(cop, 'func(3, b: :c)')
expect(cop.messages).to eq(['Use hash rockets syntax.'])
end
it 'registers an offense when using hash rockets ' \
'and no elements have a symbol value' do
inspect_source(cop, 'x = { :a => 1, :b => 2 }')
expect(cop.messages)
.to eq(['Use the new Ruby 1.9 hash syntax.',
'Use the new Ruby 1.9 hash syntax.'])
end
it 'registers an offense for hashes with elements on multiple lines' do
inspect_source(cop, "x = { a: :b,\n c: :d }")
expect(cop.messages)
.to eq(['Use hash rockets syntax.', 'Use hash rockets syntax.'])
end
it 'auto-corrects to ruby19 style when there are no symbol values' do
new_source = autocorrect_source(cop, '{ :a => 1, :b => 2 }')
expect(new_source).to eq('{ a: 1, b: 2 }')
end
it 'auto-corrects to hash rockets ' \
'when there is an element with a symbol value' do
new_source = autocorrect_source(cop, '{ a: 1, :b => :c }')
expect(new_source).to eq('{ :a => 1, :b => :c }')
end
it 'auto-corrects to hash rockets ' \
'when all elements have symbol value' do
new_source = autocorrect_source(cop, '{ a: :b, c: :d }')
expect(new_source).to eq('{ :a => :b, :c => :d }')
end
it 'auto-correct does not change anything when the hash ' \
'is already ruby19 style and there are no symbol values' do
new_source = autocorrect_source(cop, '{ a: 1, b: 2 }')
expect(new_source).to eq('{ a: 1, b: 2 }')
end
end
end
context 'configured to enforce hash rockets style' do
let(:cop_config) do
{
'EnforcedStyle' => 'hash_rockets',
'SupportedStyles' => %w[ruby19 hash_rockets],
'UseHashRocketsWithSymbolValues' => false
}
end
it 'registers offense for Ruby 1.9 style' do
inspect_source(cop, 'x = { a: 0 }')
expect(cop.messages).to eq(['Use hash rockets syntax.'])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'ruby19')
end
it 'registers an offense for mixed syntax' do
inspect_source(cop, 'x = { :a => 0, b: 1 }')
expect(cop.messages).to eq(['Use hash rockets syntax.'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'registers an offense for 1.9 style in method calls' do
inspect_source(cop, 'func(3, a: 0)')
expect(cop.messages).to eq(['Use hash rockets syntax.'])
end
it 'accepts hash rockets in a hash literal' do
inspect_source(cop, 'x = { :a => 0, :b => 1 }')
expect(cop.messages).to be_empty
end
it 'accepts hash rockets in method calls' do
inspect_source(cop, 'func(3, :a => 0)')
expect(cop.messages).to be_empty
end
it 'accepts an empty hash' do
inspect_source(cop, '{}')
expect(cop.messages).to be_empty
end
it 'auto-corrects new style to hash rockets' do
new_source = autocorrect_source(cop, '{ a: 1, b: 2}')
expect(new_source).to eq('{ :a => 1, :b => 2}')
end
context 'UseHashRocketsWithSymbolValues has no impact' do
let(:cop_config) do
{
'EnforcedStyle' => 'hash_rockets',
'SupportedStyles' => %w[ruby19 hash_rockets],
'UseHashRocketsWithSymbolValues' => true
}
end
it 'does not register an offense when there is a symbol value' do
inspect_source(cop, '{ :a => :b, :c => :d }')
expect(cop.messages).to be_empty
end
end
end
context 'configured to enforce ruby 1.9 style with no mixed keys' do
context 'UseHashRocketsWithSymbolValues disabled' do
let(:cop_config) do
{
'EnforcedStyle' => 'ruby19_no_mixed_keys',
'UseHashRocketsWithSymbolValues' => false
}
end
it 'accepts new syntax in a hash literal' do
inspect_source(cop, 'x = { a: 0, b: 1 }')
expect(cop.messages).to be_empty
end
it 'registers offense for hash rocket syntax when new is possible' do
inspect_source(cop, 'x = { :a => 0 }')
expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
expect(cop.config_to_allow_offenses)
.to eq('EnforcedStyle' => 'hash_rockets')
end
it 'registers an offense for mixed syntax when new is possible' do
inspect_source(cop, 'x = { :a => 0, b: 1 }')
expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'accepts new syntax in method calls' do
inspect_source(cop, 'func(3, a: 0)')
expect(cop.messages).to be_empty
end
it 'registers an offense for hash rockets in method calls' do
inspect_source(cop, 'func(3, :a => 0)')
expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
end
it 'accepts hash rockets when keys have different types' do
inspect_source(cop, 'x = { :a => 0, "b" => 1 }')
expect(cop.messages).to be_empty
end
it 'accepts an empty hash' do
inspect_source(cop, '{}')
expect(cop.messages).to be_empty
end
it 'registers an offense when keys have different types and styles' do
inspect_source(cop, 'x = { a: 0, "b" => 1 }')
expect(cop.messages).to eq(["Don't mix styles in the same hash."])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
context 'ruby < 2.2', :ruby21 do
it 'accepts hash rockets when keys have whitespaces in them' do
inspect_source(cop, 'x = { :"t o" => 0, :b => 1 }')
expect(cop.messages).to be_empty
end
it 'registers an offense when keys have whitespaces and mix styles' do
inspect_source(cop, 'x = { :"t o" => 0, b: 1 }')
expect(cop.messages).to eq(["Don't mix styles in the same hash."])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'accepts hash rockets when keys have special symbols in them' do
inspect_source(cop, 'x = { :"\tab" => 1, :b => 1 }')
expect(cop.messages).to be_empty
end
it 'registers an offense when keys have special symbols and '\
'mix styles' do
inspect_source(cop, 'x = { :"\tab" => 1, b: 1 }')
expect(cop.messages).to eq(["Don't mix styles in the same hash."])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'accepts hash rockets when keys start with a digit' do
inspect_source(cop, 'x = { :"1" => 1, :b => 1 }')
expect(cop.messages).to be_empty
end
it 'registers an offense when keys start with a digit and mix styles' do
inspect_source(cop, 'x = { :"1" => 1, b: 1 }')
expect(cop.messages).to eq(["Don't mix styles in the same hash."])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
end
context 'ruby >= 2.2', :ruby22 do
it 'registers an offense when keys have whitespaces in them' do
inspect_source(cop, 'x = { :"t o" => 0 }')
expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
end
it 'registers an offense when keys have special symbols in them' do
inspect_source(cop, 'x = { :"\tab" => 1 }')
expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
end
it 'registers an offense when keys start with a digit' do
inspect_source(cop, 'x = { :"1" => 1 }')
expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
end
end
it 'auto-corrects old to new style' do
new_source = autocorrect_source(cop, '{ :a => 1, :b => 2 }')
expect(new_source).to eq('{ a: 1, b: 2 }')
end
it 'auto-corrects to hash rockets when new style cannot be used ' \
'for all' do
new_source = autocorrect_source(cop, '{ a: 1, "b" => 2 }')
expect(new_source).to eq('{ :a => 1, "b" => 2 }')
end
end
context 'UseHashRocketsWithSymbolValues enabled' do
let(:cop_config) do
{
'EnforcedStyle' => 'ruby19_no_mixed_keys',
'UseHashRocketsWithSymbolValues' => true
}
end
it 'registers an offense when any element uses a symbol for the value' do
inspect_source(cop, 'x = { a: 1, b: :c }')
expect(cop.messages)
.to eq(['Use hash rockets syntax.', 'Use hash rockets syntax.'])
end
it 'registers an offense when any element has a symbol value ' \
'in method calls' do
inspect_source(cop, 'func(3, b: :c)')
expect(cop.messages).to eq(['Use hash rockets syntax.'])
end
it 'auto-corrects to hash rockets ' \
'when there is an element with a symbol value' do
new_source = autocorrect_source(cop, '{ a: 1, :b => :c }')
expect(new_source).to eq('{ :a => 1, :b => :c }')
end
it 'auto-corrects to hash rockets ' \
'when all elements have symbol value' do
new_source = autocorrect_source(cop, '{ a: :b, c: :d }')
expect(new_source).to eq('{ :a => :b, :c => :d }')
end
it 'accepts new syntax in a hash literal' do
inspect_source(cop, 'x = { a: 0, b: 1 }')
expect(cop.messages).to be_empty
end
it 'registers offense for hash rocket syntax when new is possible' do
inspect_source(cop, 'x = { :a => 0 }')
expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
expect(cop.config_to_allow_offenses)
.to eq('EnforcedStyle' => 'hash_rockets')
end
it 'registers an offense for mixed syntax when new is possible' do
inspect_source(cop, 'x = { :a => 0, b: 1 }')
expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'accepts new syntax in method calls' do
inspect_source(cop, 'func(3, a: 0)')
expect(cop.messages).to be_empty
end
it 'registers an offense for hash rockets in method calls' do
inspect_source(cop, 'func(3, :a => 0)')
expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
end
it 'accepts hash rockets when keys have different types' do
inspect_source(cop, 'x = { :a => 0, "b" => 1 }')
expect(cop.messages).to be_empty
end
it 'accepts an empty hash' do
inspect_source(cop, '{}')
expect(cop.messages).to be_empty
end
it 'registers an offense when keys have different types and styles' do
inspect_source(cop, 'x = { a: 0, "b" => 1 }')
expect(cop.messages).to eq(["Don't mix styles in the same hash."])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
context 'ruby < 2.2', :ruby21 do
it 'accepts hash rockets when keys have whitespaces in them' do
inspect_source(cop, 'x = { :"t o" => 0, :b => 1 }')
expect(cop.messages).to be_empty
end
it 'registers an offense when keys have whitespaces and mix styles' do
inspect_source(cop, 'x = { :"t o" => 0, b: 1 }')
expect(cop.messages).to eq(["Don't mix styles in the same hash."])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'accepts hash rockets when keys have special symbols in them' do
inspect_source(cop, 'x = { :"\tab" => 1, :b => 1 }')
expect(cop.messages).to be_empty
end
it 'registers an offense when keys have special symbols and ' \
'mix styles' do
inspect_source(cop, 'x = { :"\tab" => 1, b: 1 }')
expect(cop.messages).to eq(["Don't mix styles in the same hash."])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'accepts hash rockets when keys start with a digit' do
inspect_source(cop, 'x = { :"1" => 1, :b => 1 }')
expect(cop.messages).to be_empty
end
it 'registers an offense when keys start with a digit and mix styles' do
inspect_source(cop, 'x = { :"1" => 1, b: 1 }')
expect(cop.messages).to eq(["Don't mix styles in the same hash."])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
end
context 'ruby >= 2.2', :ruby22 do
it 'registers an offense when keys have whitespaces in them' do
inspect_source(cop, 'x = { :"t o" => 0 }')
expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
end
it 'registers an offense when keys have special symbols in them' do
inspect_source(cop, 'x = { :"\tab" => 1 }')
expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
end
it 'registers an offense when keys start with a digit' do
inspect_source(cop, 'x = { :"1" => 1 }')
expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
end
end
it 'auto-corrects old to new style' do
new_source = autocorrect_source(cop, '{ :a => 1, :b => 2 }')
expect(new_source).to eq('{ a: 1, b: 2 }')
end
it 'auto-corrects to hash rockets when new style cannot be used ' \
'for all' do
new_source = autocorrect_source(cop, '{ a: 1, "b" => 2 }')
expect(new_source).to eq('{ :a => 1, "b" => 2 }')
end
end
end
context 'configured to enforce no mixed keys' do
let(:cop_config) do
{
'EnforcedStyle' => 'no_mixed_keys'
}
end
it 'accepts new syntax in a hash literal' do
inspect_source(cop, 'x = { a: 0, b: 1 }')
expect(cop.messages).to be_empty
end
it 'accepts the hash rocket syntax when new is possible' do
inspect_source(cop, 'x = { :a => 0 }')
expect(cop.messages).to be_empty
end
it 'registers an offense for mixed syntax when new is possible' do
inspect_source(cop, 'x = { :a => 0, b: 1 }')
expect(cop.messages).to eq(['Don\'t mix styles in the same hash.'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'accepts new syntax in method calls' do
inspect_source(cop, 'func(3, a: 0)')
expect(cop.messages).to be_empty
end
it 'accepts hash rockets in method calls' do
inspect_source(cop, 'func(3, :a => 0)')
expect(cop.messages).to be_empty
end
it 'accepts hash rockets when keys have different types' do
inspect_source(cop, 'x = { :a => 0, "b" => 1 }')
expect(cop.messages).to be_empty
end
it 'accepts an empty hash' do
inspect_source(cop, '{}')
expect(cop.messages).to be_empty
end
it 'registers an offense when keys have different types and styles' do
inspect_source(cop, 'x = { a: 0, "b" => 1 }')
expect(cop.messages).to eq(["Don't mix styles in the same hash."])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'accepts hash rockets when keys have whitespaces in them' do
inspect_source(cop, 'x = { :"t o" => 0, :b => 1 }')
expect(cop.messages).to be_empty
end
it 'registers an offense when keys have whitespaces and mix styles' do
inspect_source(cop, 'x = { :"t o" => 0, b: 1 }')
expect(cop.messages).to eq(["Don't mix styles in the same hash."])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'accepts hash rockets when keys have special symbols in them' do
inspect_source(cop, 'x = { :"\tab" => 1, :b => 1 }')
expect(cop.messages).to be_empty
end
it 'registers an offense when keys have special symbols and '\
'mix styles' do
inspect_source(cop, 'x = { :"\tab" => 1, b: 1 }')
expect(cop.messages).to eq(["Don't mix styles in the same hash."])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'accepts hash rockets when keys start with a digit' do
inspect_source(cop, 'x = { :"1" => 1, :b => 1 }')
expect(cop.messages).to be_empty
end
it 'registers an offense when keys start with a digit and mix styles' do
inspect_source(cop, 'x = { :"1" => 1, b: 1 }')
expect(cop.messages).to eq(["Don't mix styles in the same hash."])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'does not auto-correct old to new style' do
new_source = autocorrect_source(cop, '{ :a => 1, :b => 2 }')
expect(new_source).to eq('{ :a => 1, :b => 2 }')
end
it 'does not auto-correct new to hash rockets style' do
new_source = autocorrect_source(cop, '{ a: 1, b: 2 }')
expect(new_source).to eq('{ a: 1, b: 2 }')
end
it 'auto-corrects mixed key hashes' do
new_source = autocorrect_source(cop, '{ a: 1, :b => 2 }')
expect(new_source).to eq('{ a: 1, b: 2 }')
end
it 'auto-corrects to hash rockets when new style cannot be used ' \
'for all' do
new_source = autocorrect_source(cop, '{ a: 1, "b" => 2 }')
expect(new_source).to eq('{ :a => 1, "b" => 2 }')
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/identical_conditional_branches_spec.rb 0000664 0000000 0000000 00000012012 13070542236 0031200 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::IdenticalConditionalBranches do
subject(:cop) { described_class.new }
before do
inspect_source(cop, source)
end
context 'on if..else with identical bodies' do
let(:source) do
['if something',
' do_x',
'else',
' do_x',
'end']
end
it 'registers an offense' do
expect(cop.offenses.size).to eq(2)
expect(cop.messages).to eq([
'Move `do_x` out of the conditional.',
'Move `do_x` out of the conditional.'
])
end
end
context 'on if..else with identical trailing lines' do
let(:source) do
['if something',
' method_call_here(1, 2, 3)',
' do_x',
'else',
' 1 + 2 + 3',
' do_x',
'end']
end
it 'registers an offense' do
expect(cop.offenses.size).to eq(2)
expect(cop.messages).to eq([
'Move `do_x` out of the conditional.',
'Move `do_x` out of the conditional.'
])
end
end
context 'on if..else with identical leading lines' do
let(:source) do
['if something',
' do_x',
' method_call_here(1, 2, 3)',
'else',
' do_x',
' 1 + 2 + 3',
'end']
end
it 'registers an offense' do
expect(cop.offenses.size).to eq(2)
expect(cop.messages).to eq([
'Move `do_x` out of the conditional.',
'Move `do_x` out of the conditional.'
])
end
end
context 'on if..elsif with no else' do
let(:source) do
['if something',
' do_x',
'elsif something_else',
' do_x',
'end']
end
it "doesn't register an offense" do
expect(cop.offenses).to be_empty
end
end
context 'on if..else with slightly different trailing lines' do
let(:source) do
['if something',
' do_x(1)',
'else',
' do_x(2)',
'end']
end
it "doesn't register an offense" do
expect(cop.offenses).to be_empty
end
end
context 'on case with identical bodies' do
let(:source) do
['case something',
'when :a',
' do_x',
'when :b',
' do_x',
'else',
' do_x',
'end']
end
it 'registers an offense' do
expect(cop.offenses.size).to eq(3)
expect(cop.messages).to eq([
'Move `do_x` out of the conditional.',
'Move `do_x` out of the conditional.',
'Move `do_x` out of the conditional.'
])
end
end
# Regression: https://github.com/bbatsov/rubocop/issues/3868
context 'when one of the case branches is empty' do
let(:source) do
['case value',
'when cond1',
'else',
' if cond2',
' else',
' end',
'end']
end
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
context 'on case with identical trailing lines' do
let(:source) do
['case something',
'when :a',
' x1',
' do_x',
'when :b',
' x2',
' do_x',
'else',
' x3',
' do_x',
'end']
end
it 'registers an offense' do
expect(cop.offenses.size).to eq(3)
expect(cop.messages).to eq([
'Move `do_x` out of the conditional.',
'Move `do_x` out of the conditional.',
'Move `do_x` out of the conditional.'
])
end
end
context 'on case with identical leading lines' do
let(:source) do
['case something',
'when :a',
' do_x',
' x1',
'when :b',
' do_x',
' x2',
'else',
' do_x',
' x3',
'end']
end
it 'registers an offense' do
expect(cop.offenses.size).to eq(3)
expect(cop.messages).to eq([
'Move `do_x` out of the conditional.',
'Move `do_x` out of the conditional.',
'Move `do_x` out of the conditional.'
])
end
end
context 'on case without else' do
let(:source) do
['case something',
'when :a',
' do_x',
'when :b',
' do_x',
'end']
end
it "doesn't register an offense" do
expect(cop.offenses).to be_empty
end
end
context 'on case with empty when' do
let(:source) do
['case something',
'when :a',
' do_x',
' do_y',
'when :b',
'else',
' do_x',
' do_z',
'end']
end
it "doesn't register an offense" do
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/if_inside_else_spec.rb 0000664 0000000 0000000 00000007043 13070542236 0025765 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::IfInsideElse do
subject(:cop) { described_class.new }
it 'catches an if node nested inside an else' do
inspect_source(cop, ['if a',
' blah',
'else',
' if b',
' foo',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['Convert `if` nested inside `else` to `elsif`.']
)
expect(cop.highlights).to eq(['if'])
end
it 'catches an if..else nested inside an else' do
inspect_source(cop, ['if a',
' blah',
'else',
' if b',
' foo',
' else',
' bar',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['Convert `if` nested inside `else` to `elsif`.']
)
expect(cop.highlights).to eq(['if'])
end
it 'catches a modifier if nested inside an else' do
inspect_source(cop, ['if a',
' blah',
'else',
' foo if b',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['Convert `if` nested inside `else` to `elsif`.']
)
expect(cop.highlights).to eq(['if'])
end
it "isn't offended if there is a statement following the if node" do
inspect_source(cop, ['if a',
' blah',
'else',
' if b',
' foo',
' end',
' bar',
'end'])
expect(cop.offenses).to be_empty
end
it "isn't offended if there is a statement preceding the if node" do
inspect_source(cop, ['if a',
' blah',
'else',
' bar',
' if b',
' foo',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it "isn't offended by if..elsif..else" do
inspect_source(cop, ['if a',
' blah',
'elsif b',
' blah',
'else',
' blah',
'end'])
expect(cop.offenses).to be_empty
end
it 'ignores unless inside else' do
inspect_source(cop, ['if a',
' blah',
'else',
' unless b',
' foo',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'ignores if inside unless' do
inspect_source(cop, ['unless a',
' if b',
' foo',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'ignores nested ternary expressions' do
inspect_source(cop, 'a ? b : c ? d : e')
expect(cop.offenses).to be_empty
end
it 'ignores ternary inside if..else' do
inspect_source(cop, ['if a',
' blah',
'else',
' a ? b : c',
'end'])
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/if_unless_modifier_of_if_unless_spec.rb 0000664 0000000 0000000 00000002723 13070542236 0031424 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::IfUnlessModifierOfIfUnless do
include StatementModifierHelper
subject(:cop) { described_class.new }
it 'provides a good error message' do
source = 'condition ? then_part : else_part unless external_condition'
inspect_source(cop, source)
expect(cop.messages)
.to eq(['Avoid modifier `unless` after another conditional.'])
end
context 'ternary with modifier' do
let(:source) do
'condition ? then_part : else_part unless external_condition'
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
end
context 'conditional with modifier' do
let(:source) do
['unless condition',
' then_part',
'end if external_condition']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
end
context 'conditional with modifier in body' do
let(:source) do
['if condition',
' then_part if maybe?',
'end']
end
it 'accepts' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
context 'nested conditionals' do
let(:source) do
['if external_condition',
' if condition',
' then_part',
' end',
'end']
end
it 'accepts' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/if_unless_modifier_spec.rb 0000664 0000000 0000000 00000022155 13070542236 0026672 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::IfUnlessModifier do
include StatementModifierHelper
subject(:cop) { described_class.new(config) }
let(:config) do
hash = { 'Metrics/LineLength' => { 'Max' => 80 } }
RuboCop::Config.new(hash)
end
context 'multiline if that fits on one line' do
let(:source) do
["if #{condition}",
" #{body}",
'', # Empty lines should make no difference.
'end']
end
let(:condition) { 'a' * 38 }
let(:body) { 'b' * 38 }
it 'registers an offense' do
# This if statement fits exactly on one line if written as a
# modifier.
expect("#{body} if #{condition}".length).to eq(80)
inspect_source(cop, source)
expect(cop.messages).to eq(
['Favor modifier `if` usage when having a single-line' \
' body. Another good alternative is the usage of control flow' \
' `&&`/`||`.']
)
end
it 'does auto-correction' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq "#{body} if #{condition}"
end
context 'and has two statements separated by semicolon' do
let(:source) do
['if condition',
' do_this; do_that',
'end']
end
it 'accepts' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
context 'multiline if that fits on one line with comment on first line' do
let(:source) do
['if a # comment',
' b',
'end']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(
['Favor modifier `if` usage when having a single-line' \
' body. Another good alternative is the usage of control flow' \
' `&&`/`||`.']
)
end
it 'does auto-correction and preserves comment' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq 'b if a # comment'
end
end
context 'multiline if that fits on one line with comment near end' do
let(:source) do
['if a',
' b',
'end # comment',
'if a',
' b',
' # comment',
'end']
end
it 'accepts' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
context 'short multiline if near an else etc' do
let(:source) do
['if x',
' y',
'elsif x1',
' y1',
'else',
' z',
'end',
'n = a ? 0 : 1',
'm = 3 if m0',
'',
'if a',
' b',
'end']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'does auto-correction' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq(['if x',
' y',
'elsif x1',
' y1',
'else',
' z',
'end',
'n = a ? 0 : 1',
'm = 3 if m0',
'',
'b if a'].join("\n"))
end
end
it "accepts multiline if that doesn't fit on one line" do
check_too_long(cop, 'if')
end
it 'accepts multiline if whose body is more than one line' do
check_short_multiline(cop, 'if')
end
context 'multiline unless that fits on one line' do
let(:source) do
['unless a',
' b',
'end']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(
['Favor modifier `unless` usage when having a single-line' \
' body. Another good alternative is the usage of control flow' \
' `&&`/`||`.']
)
end
it 'does auto-correction' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq 'b unless a'
end
end
it 'accepts code with EOL comment since user might want to keep it' do
inspect_source(cop, ['unless a',
' b # A comment',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts if-else-end' do
inspect_source(cop,
'if args.last.is_a? Hash then args.pop else ' \
'Hash.new end')
expect(cop.messages).to be_empty
end
it 'accepts an empty condition' do
check_empty(cop, 'if')
check_empty(cop, 'unless')
end
it 'accepts if/elsif' do
inspect_source(cop, ['if test',
' something',
'elsif test2',
' something_else',
'end'])
expect(cop.offenses).to be_empty
end
context 'with implicit match conditional' do
let(:source) do
[
" if #{conditional}",
" #{body}",
' end'
]
end
let(:body) { 'b' * 36 }
context 'when a multiline if fits on one line' do
let(:conditional) { "/#{'a' * 36}/" }
it 'registers an offense' do
expect(" #{body} if #{conditional}".length).to eq(80)
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'does auto-correction' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq " #{body} if #{conditional}"
end
end
context "when a multiline if doesn't fit on one line" do
let(:conditional) { "/#{'a' * 37}/" }
it 'accepts' do
expect(" #{body} if #{conditional}".length).to eq(81)
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
context 'when the maximum line length is specified by the cop itself' do
let(:config) do
hash = {
'Metrics/LineLength' => { 'Max' => 100 },
'Style/IfUnlessModifier' => { 'MaxLineLength' => 80 }
}
RuboCop::Config.new(hash)
end
it "accepts multiline if that doesn't fit on one line" do
check_too_long(cop, 'if')
end
it "accepts multiline unless that doesn't fit on one line" do
check_too_long(cop, 'unless')
end
end
end
it 'accepts if-end followed by a chained call' do
inspect_source(cop, ['if test',
' something',
'end.inspect'])
expect(cop.messages).to be_empty
end
it "doesn't break if-end when used as RHS of local var assignment" do
corrected = autocorrect_source(cop, ['a = if b',
' 1',
'end'])
expect(corrected).to eq 'a = (1 if b)'
end
it "doesn't break if-end when used as RHS of instance var assignment" do
corrected = autocorrect_source(cop, ['@a = if b',
' 1',
'end'])
expect(corrected).to eq '@a = (1 if b)'
end
it "doesn't break if-end when used as RHS of class var assignment" do
corrected = autocorrect_source(cop, ['@@a = if b',
' 1',
'end'])
expect(corrected).to eq '@@a = (1 if b)'
end
it "doesn't break if-end when used as RHS of constant assignment" do
corrected = autocorrect_source(cop, ['A = if b',
' 1',
'end'])
expect(corrected).to eq 'A = (1 if b)'
end
it "doesn't break if-end when used as RHS of binary arithmetic" do
corrected = autocorrect_source(cop, ['a + if b',
' 1',
'end'])
expect(corrected).to eq 'a + (1 if b)'
end
it 'accepts if-end when used as LHS of binary arithmetic' do
inspect_source(cop, ['if test',
' 1',
'end + 2'])
expect(cop.messages).to be_empty
end
context 'if-end is argument to a parenthesized method call' do
it "doesn't add redundant parentheses" do
corrected = autocorrect_source(cop, ['puts("string", if a',
' 1',
'end)'])
expect(corrected).to eq 'puts("string", 1 if a)'
end
end
context 'if-end is argument to a non-parenthesized method call' do
it 'adds parentheses so as not to change meaning' do
corrected = autocorrect_source(cop, ['puts "string", if a',
' 1',
'end'])
expect(corrected).to eq 'puts "string", (1 if a)'
end
end
context 'if-end with conditional as body' do
let(:source) do
['if condition',
' foo ? "bar" : "baz"',
'end']
end
it 'accepts' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
context 'unless-end with conditional as body' do
let(:source) do
['unless condition',
' foo ? "bar" : "baz"',
'end']
end
it 'accepts' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/if_with_semicolon_spec.rb 0000664 0000000 0000000 00000001227 13070542236 0026523 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::IfWithSemicolon do
subject(:cop) { described_class.new }
it 'registers an offense for one line if/;/end' do
inspect_source(cop, 'if cond; run else dont end')
expect(cop.messages).to eq(
['Do not use if x; Use the ternary operator instead.']
)
end
it 'accepts one line if/then/end' do
inspect_source(cop, 'if cond then run else dont end')
expect(cop.messages).to be_empty
end
it 'can handle modifier conditionals' do
inspect_source(cop, ['class Hash',
'end if RUBY_VERSION < "1.8.7"'])
expect(cop.messages).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/implicit_runtime_error_spec.rb 0000664 0000000 0000000 00000002570 13070542236 0027612 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::ImplicitRuntimeError do
subject(:cop) { described_class.new }
%w[raise fail].each do |method|
it "registers an offense for #{method} 'message'" do
inspect_source(cop, "#{method} 'message'")
expect(cop.offenses.size).to eq 1
expect(cop.messages).to eq(["Use `#{method}` with an explicit " \
'exception class and message, rather than ' \
'just a message.'])
expect(cop.highlights).to eq(["#{method} 'message'"])
end
it "registers an offense for #{method} with a multiline string" do
inspect_source(cop, ["#{method} 'message' \\", "'2nd line'"])
expect(cop.offenses.size).to eq 1
expect(cop.messages).to eq(["Use `#{method}` with an explicit " \
'exception class and message, rather than ' \
'just a message.'])
expect(cop.highlights).to eq(["#{method} 'message' \\\n'2nd line'"])
end
it "doesn't register an offense for #{method} StandardError, 'message'" do
inspect_source(cop, "#{method} StandardError, 'message'")
expect(cop.offenses).to be_empty
end
it "doesn't register an offense for #{method} with no arguments" do
inspect_source(cop, method)
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/indent_array_spec.rb 0000664 0000000 0000000 00000040316 13070542236 0025503 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::IndentArray do
subject(:cop) { described_class.new(config) }
let(:config) do
supported_styles = {
'SupportedStyles' => %w[special_inside_parentheses consistent
align_brackets]
}
RuboCop::Config.new('Style/IndentArray' =>
cop_config.merge(supported_styles).merge(
'IndentationWidth' => cop_indent
),
'Style/IndentationWidth' => { 'Width' => 2 })
end
let(:cop_config) { { 'EnforcedStyle' => 'special_inside_parentheses' } }
let(:cop_indent) { nil } # use indent from Style/IndentationWidth
context 'when array is operand' do
it 'accepts correctly indented first element' do
inspect_source(cop,
['a << [',
' 1',
']'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for incorrectly indented first element' do
inspect_source(cop,
['a << [',
' 1',
']'])
expect(cop.highlights).to eq(['1'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'auto-corrects incorrectly indented first element' do
corrected = autocorrect_source(cop, ['a << [',
' 1',
']'])
expect(corrected).to eq ['a << [',
' 1',
']'].join("\n")
end
it 'registers an offense for incorrectly indented ]' do
inspect_source(cop,
['a << [',
' ]'])
expect(cop.highlights).to eq([']'])
expect(cop.messages)
.to eq(['Indent the right bracket the same as the start of the line ' \
'where the left bracket is.'])
expect(cop.config_to_allow_offenses).to be_empty
end
context 'when indentation width is overridden for this cop' do
let(:cop_indent) { 4 }
it 'accepts correctly indented first element' do
inspect_source(cop,
['a << [',
' 1',
']'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for incorrectly indented first element' do
inspect_source(cop,
['a << [',
' 1',
']'])
expect(cop.highlights).to eq(['1'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
end
end
context 'when array is argument to setter' do
it 'accepts correctly indented first element' do
inspect_source(cop,
[' config.rack_cache = [',
' "rails:/",',
' "rails:/",',
' false',
' ]'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for incorrectly indented first element' do
inspect_source(cop,
[' config.rack_cache = [',
' "rails:/",',
' "rails:/",',
' false',
' ]'])
expect(cop.highlights).to eq(['"rails:/"'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
end
context 'when array is right hand side in assignment' do
it 'registers an offense for incorrectly indented first element' do
inspect_source(cop, ['a = [',
' 1,',
' 2,',
' 3',
']'])
expect(cop.messages)
.to eq(['Use 2 spaces for indentation in an array, relative to the ' \
'start of the line where the left square bracket is.'])
expect(cop.highlights).to eq(['1'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'auto-corrects incorrectly indented first element' do
corrected = autocorrect_source(cop, ['a = [',
' 1,',
' 2,',
' 3',
']'])
expect(corrected).to eq ['a = [',
' 1,',
' 2,',
' 3',
']'].join("\n")
end
it 'accepts correctly indented first element' do
inspect_source(cop,
['a = [',
' 1',
']'])
expect(cop.offenses).to be_empty
end
it 'accepts several elements per line' do
inspect_source(cop,
['a = [',
' 1, 2',
']'])
expect(cop.offenses).to be_empty
end
it 'accepts a first element on the same line as the left bracket' do
inspect_source(cop,
['a = [1,',
' 2]'])
expect(cop.offenses).to be_empty
end
it 'accepts single line array' do
inspect_source(cop,
'a = [1, 2]')
expect(cop.offenses).to be_empty
end
it 'accepts an empty array' do
inspect_source(cop,
'a = []')
expect(cop.offenses).to be_empty
end
it 'accepts multi-assignments with brackets' do
inspect_source(cop,
'a, b = [b, a]')
expect(cop.offenses).to be_empty
end
it 'accepts multi-assignments with no brackets' do
inspect_source(cop,
'a, b = b, a')
expect(cop.offenses).to be_empty
end
end
context 'when array is method argument' do
context 'and arguments are surrounded by parentheses' do
context 'and EnforcedStyle is special_inside_parentheses' do
it 'accepts special indentation for first argument' do
inspect_source(cop,
# Only the function calls are affected by
# EnforcedStyle setting. Other indentation shall be
# the same regardless of EnforcedStyle.
['h = [',
' 1',
']',
'func([',
' 1',
' ])',
'func(x, [',
' 1',
' ])',
'h = [1',
']',
'func([1',
' ])',
'func(x, [1',
' ])'])
expect(cop.offenses).to be_empty
end
it "registers an offense for 'consistent' indentation" do
inspect_source(cop,
['func([',
' 1',
'])'])
expect(cop.messages)
.to eq(['Use 2 spaces for indentation in an array, relative to ' \
'the first position after the preceding left parenthesis.',
'Indent the right bracket the same as the first position ' \
'after the preceding left parenthesis.'])
expect(cop.config_to_allow_offenses)
.to eq('EnforcedStyle' => 'consistent')
end
it "registers an offense for 'align_brackets' indentation" do
inspect_source(cop,
['var = [',
' 1',
' ]'])
# since there are no parens, warning message is for 'consistent' style
expect(cop.messages)
.to eq(['Use 2 spaces for indentation in an array, relative to ' \
'the start of the line where the left square bracket is.',
'Indent the right bracket the same as the start of the ' \
'line where the left bracket is.'])
expect(cop.config_to_allow_offenses)
.to eq('EnforcedStyle' => 'align_brackets')
end
it 'auto-corrects incorrectly indented first element' do
corrected = autocorrect_source(cop, ['func([',
' 1',
'])'])
expect(corrected).to eq ['func([',
' 1',
' ])'].join("\n")
end
it 'accepts special indentation for second argument' do
inspect_source(cop,
['body.should have_tag("input", [',
' :name])'])
expect(cop.offenses).to be_empty
end
it 'accepts normal indentation for array within array' do
inspect_source(cop,
['puts(',
' [',
' [1, 2]',
' ]',
')'])
expect(cop.offenses).to be_empty
end
end
context 'and EnforcedStyle is consistent' do
let(:cop_config) { { 'EnforcedStyle' => 'consistent' } }
it 'accepts normal indentation for first argument' do
inspect_source(cop,
# Only the function calls are affected by
# EnforcedStyle setting. Other indentation shall be
# the same regardless of EnforcedStyle.
['h = [',
' 1',
']',
'func([',
' 1',
'])',
'func(x, [',
' 1',
'])',
'h = [1',
']',
'func([1',
'])',
'func(x, [1',
'])'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for incorrect indentation' do
inspect_source(cop,
['func([',
' 1',
' ])'])
expect(cop.messages)
.to eq(['Use 2 spaces for indentation in an array, relative to ' \
'the start of the line where the left square bracket is.',
'Indent the right bracket the same as the start of the ' \
'line where the left bracket is.'])
expect(cop.config_to_allow_offenses)
.to eq('EnforcedStyle' => 'special_inside_parentheses')
end
it 'accepts normal indentation for second argument' do
inspect_source(cop,
['body.should have_tag("input", [',
' :name])'])
expect(cop.offenses).to be_empty
end
end
end
context 'and argument are not surrounded by parentheses' do
it 'accepts bracketless array' do
inspect_source(cop,
'func 1, 2')
expect(cop.offenses).to be_empty
end
it 'accepts single line array with brackets' do
inspect_source(cop,
'func x, [1, 2]')
expect(cop.offenses).to be_empty
end
it 'accepts a correctly indented multi-line array with brackets' do
inspect_source(cop,
['func x, [',
' 1, 2]'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for incorrectly indented multi-line array ' \
'with brackets' do
inspect_source(cop,
['func x, [',
' 1, 2]'])
expect(cop.messages)
.to eq(['Use 2 spaces for indentation in an array, relative to the ' \
'start of the line where the left square bracket is.'])
expect(cop.highlights).to eq(['1'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
end
end
context 'when EnforcedStyle is align_brackets' do
let(:cop_config) { { 'EnforcedStyle' => 'align_brackets' } }
it 'accepts correctly indented first element' do
inspect_source(cop,
['a = [',
' 1',
' ]'])
expect(cop.offenses).to be_empty
end
it 'accepts several elements per line' do
inspect_source(cop,
['a = [',
' 1, 2',
' ]'])
expect(cop.offenses).to be_empty
end
it 'accepts a first element on the same line as the left bracket' do
inspect_source(cop,
['a = [1,',
' 2]'])
expect(cop.offenses).to be_empty
end
it 'accepts single line array' do
inspect_source(cop,
'a = [1, 2]')
expect(cop.offenses).to be_empty
end
it 'accepts an empty array' do
inspect_source(cop,
'a = []')
expect(cop.offenses).to be_empty
end
it 'accepts multi-assignments with brackets' do
inspect_source(cop,
'a, b = [b, a]')
expect(cop.offenses).to be_empty
end
it 'accepts multi-assignments with no brackets' do
inspect_source(cop,
'a, b = b, a')
expect(cop.offenses).to be_empty
end
context "when 'consistent' style is used" do
it 'registers an offense for incorrect indentation' do
inspect_source(cop,
['func([',
' 1',
'])'])
expect(cop.messages)
.to eq(['Use 2 spaces for indentation in an array, relative to the' \
' position of the opening bracket.',
'Indent the right bracket the same as the left bracket.'])
expect(cop.config_to_allow_offenses)
.to eq('EnforcedStyle' => 'consistent')
end
it 'auto-corrects incorrectly indented first element' do
corrected = autocorrect_source(cop, ['var = [',
' 1',
']'])
expect(corrected).to eq ['var = [',
' 1',
' ]'].join("\n")
end
end
context "when 'special_inside_parentheses' style is used" do
it 'registers an offense for incorrect indentation' do
inspect_source(cop,
['var = [',
' 1',
']',
'func([',
' 1',
' ])'])
expect(cop.messages)
.to eq(['Use 2 spaces for indentation in an array, relative to the' \
' position of the opening bracket.',
'Indent the right bracket the same as the left bracket.'])
expect(cop.config_to_allow_offenses)
.to eq('EnforcedStyle' => 'special_inside_parentheses')
end
end
it 'registers an offense for incorrectly indented ]' do
inspect_source(cop,
['a << [',
' ]'])
expect(cop.highlights).to eq([']'])
expect(cop.messages)
.to eq(['Indent the right bracket the same as the left bracket.'])
expect(cop.config_to_allow_offenses).to be_empty
end
context 'when indentation width is overridden for this cop' do
let(:cop_indent) { 4 }
it 'accepts correctly indented first element' do
inspect_source(cop,
['a = [',
' 1',
' ]'])
expect(cop.offenses).to be_empty
end
it 'autocorrects indentation which does not match IndentationWidth' do
new_source = autocorrect_source(cop, ['a = [',
' 1',
' ]'])
expect(new_source).to eq(['a = [',
' 1',
' ]'].join("\n"))
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/indent_assignment_spec.rb 0000664 0000000 0000000 00000004726 13070542236 0026542 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::IndentAssignment, :config do
subject(:cop) { described_class.new(config) }
let(:config) do
RuboCop::Config.new('Style/IndentAssignment' => {
'IndentationWidth' => cop_indent
},
'Style/IndentationWidth' => { 'Width' => 2 })
end
let(:cop_indent) { nil } # use indentation with from Style/IndentationWidth
it 'registers an offense for incorrectly indented rhs' do
inspect_source(cop, ['a =',
'if b ; end'])
expect(cop.offenses.length).to eq(1)
expect(cop.highlights).to eq(['if b ; end'])
expect(cop.message).to eq(described_class::MSG)
end
it 'allows assignments that do not start on a newline' do
inspect_source(cop, ['a = if b',
' foo',
' end'])
expect(cop.offenses).to be_empty
end
it 'allows a properly indented rhs' do
inspect_source(cop, ['a =',
' if b ; end'])
expect(cop.offenses).to be_empty
end
it 'allows a properly indented rhs with fullwidth characters' do
inspect_source(cop, ["f 'Ｒｕｂｙ', a =",
' b'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for multi-lhs' do
inspect_source(cop, ['a,',
'b =',
'if b ; end'])
expect(cop.offenses.length).to eq(1)
expect(cop.highlights).to eq(['if b ; end'])
expect(cop.message).to eq(described_class::MSG)
end
it 'ignores comparison operators' do
inspect_source(cop, ['a ===',
'if b ; end'])
expect(cop.offenses).to be_empty
end
it 'auto-corrects indentation' do
new_source = autocorrect_source(
cop, ['a =',
'if b ; end']
)
expect(new_source)
.to eq(['a =',
' if b ; end'].join("\n"))
end
context 'when indentation width is overridden for this cop only' do
let(:cop_indent) { 7 }
it 'allows a properly indented rhs' do
inspect_source(cop, ['a =',
' if b ; end'])
expect(cop.offenses).to be_empty
end
it 'auto-corrects indentation' do
new_source = autocorrect_source(
cop, ['a =',
' if b ; end']
)
expect(new_source)
.to eq(['a =',
' if b ; end'].join("\n"))
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/indent_hash_spec.rb 0000664 0000000 0000000 00000042656 13070542236 0025321 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::IndentHash do
subject(:cop) { described_class.new(config) }
let(:config) do
supported_styles = {
'SupportedStyles' => %w[special_inside_parentheses consistent
align_braces]
}
RuboCop::Config.new('Style/AlignHash' => align_hash_config,
'Style/IndentHash' =>
cop_config.merge(supported_styles).merge(
'IndentationWidth' => cop_indent
),
'Style/IndentationWidth' => { 'Width' => 2 })
end
let(:align_hash_config) do
{
'Enabled' => true,
'EnforcedColonStyle' => 'key',
'EnforcedHashRocketStyle' => 'key'
}
end
let(:cop_config) { { 'EnforcedStyle' => 'special_inside_parentheses' } }
let(:cop_indent) { nil } # use indentation width from Style/IndentationWidth
shared_examples 'right brace' do
it 'registers an offense for incorrectly indented }' do
inspect_source(cop,
['a << {',
' }'])
expect(cop.highlights).to eq(['}'])
expect(cop.messages)
.to eq(['Indent the right brace the same as the start of the line ' \
'where the left brace is.'])
expect(cop.config_to_allow_offenses).to be_empty
end
end
context 'when the AlignHash style is separator for :' do
let(:align_hash_config) do
{
'Enabled' => true,
'EnforcedColonStyle' => 'separator',
'EnforcedHashRocketStyle' => 'key'
}
end
it 'accepts correctly indented first pair' do
inspect_source(cop,
['a << {',
' a: 1,',
' aaa: 222',
'}'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for incorrectly indented first pair with :' do
inspect_source(cop,
['a << {',
' a: 1,',
' aaa: 222',
'}'])
expect(cop.highlights).to eq(['a: 1'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
include_examples 'right brace'
end
context 'when the AlignHash style is separator for =>' do
let(:align_hash_config) do
{
'Enabled' => true,
'EnforcedColonStyle' => 'key',
'EnforcedHashRocketStyle' => 'separator'
}
end
it 'accepts correctly indented first pair' do
inspect_source(cop,
['a << {',
" 'a' => 1,",
" 'aaa' => 222",
'}'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for incorrectly indented first pair with =>' do
inspect_source(cop,
['a << {',
" 'a' => 1,",
" 'aaa' => 222",
'}'])
expect(cop.highlights).to eq(["'a' => 1"])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
include_examples 'right brace'
end
context 'when hash is operand' do
it 'accepts correctly indented first pair' do
inspect_source(cop,
['a << {',
' a: 1',
'}'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for incorrectly indented first pair' do
inspect_source(cop,
['a << {',
' a: 1',
'}'])
expect(cop.highlights).to eq(['a: 1'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'auto-corrects incorrectly indented first pair' do
corrected = autocorrect_source(cop, ['a << {',
' a: 1',
'}'])
expect(corrected).to eq ['a << {',
' a: 1',
'}'].join("\n")
end
include_examples 'right brace'
end
context 'when hash is argument to setter' do
it 'accepts correctly indented first pair' do
inspect_source(cop,
[' config.rack_cache = {',
' :metastore => "rails:/",',
' :entitystore => "rails:/",',
' :verbose => false',
' }'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for incorrectly indented first pair' do
inspect_source(cop,
[' config.rack_cache = {',
' :metastore => "rails:/",',
' :entitystore => "rails:/",',
' :verbose => false',
' }'])
expect(cop.highlights).to eq([':metastore => "rails:/"'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
end
context 'when hash is right hand side in assignment' do
it 'registers an offense for incorrectly indented first pair' do
inspect_source(cop, ['a = {',
' a: 1,',
' b: 2,',
' c: 3',
'}'])
expect(cop.messages)
.to eq(['Use 2 spaces for indentation in a hash, relative to the ' \
'start of the line where the left curly brace is.'])
expect(cop.highlights).to eq(['a: 1'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'auto-corrects incorrectly indented first pair' do
corrected = autocorrect_source(cop, ['a = {',
' a: 1,',
' b: 2,',
' c: 3',
'}'])
expect(corrected).to eq ['a = {',
' a: 1,',
' b: 2,',
' c: 3',
'}'].join("\n")
end
it 'accepts correctly indented first pair' do
inspect_source(cop,
['a = {',
' a: 1',
'}'])
expect(cop.offenses).to be_empty
end
it 'accepts several pairs per line' do
inspect_source(cop,
['a = {',
' a: 1, b: 2',
'}'])
expect(cop.offenses).to be_empty
end
it 'accepts a first pair on the same line as the left brace' do
inspect_source(cop,
['a = { "a" => 1,',
' "b" => 2 }'])
expect(cop.offenses).to be_empty
end
it 'accepts single line hash' do
inspect_source(cop,
'a = { a: 1, b: 2 }')
expect(cop.offenses).to be_empty
end
it 'accepts an empty hash' do
inspect_source(cop,
'a = {}')
expect(cop.offenses).to be_empty
end
context 'when indentation width is overridden for this cop' do
let(:cop_indent) { 3 }
it 'auto-corrects incorrectly indented first pair' do
corrected = autocorrect_source(cop, ['a = {',
' a: 1,',
' b: 2,',
' c: 3',
'}'])
expect(corrected).to eq ['a = {',
' a: 1,',
' b: 2,',
' c: 3',
'}'].join("\n")
end
it 'accepts correctly indented first pair' do
inspect_source(cop,
['a = {',
' a: 1',
'}'])
expect(cop.offenses).to be_empty
end
end
end
context 'when hash is method argument' do
context 'and arguments are surrounded by parentheses' do
context 'and EnforcedStyle is special_inside_parentheses' do
it 'accepts special indentation for first argument' do
inspect_source(cop,
# Only the function calls are affected by
# EnforcedStyle setting. Other indentation shall be
# the same regardless of EnforcedStyle.
['h = {',
' a: 1',
'}',
'func({',
' a: 1',
' })',
'func(x, {',
' a: 1',
' })',
'h = { a: 1',
'}',
'func({ a: 1',
' })',
'func(x, { a: 1',
' })'])
expect(cop.offenses).to be_empty
end
it "registers an offense for 'consistent' indentation" do
inspect_source(cop,
['func({',
' a: 1',
'})'])
expect(cop.messages)
.to eq(['Use 2 spaces for indentation in a hash, relative to the' \
' first position after the preceding left parenthesis.',
'Indent the right brace the same as the first position ' \
'after the preceding left parenthesis.'])
expect(cop.config_to_allow_offenses)
.to eq('EnforcedStyle' => 'consistent')
end
it "registers an offense for 'align_braces' indentation" do
inspect_source(cop,
['var = {',
' a: 1',
' }'])
# since there are no parens, warning message is for 'consistent' style
expect(cop.messages)
.to eq(['Use 2 spaces for indentation in a hash, relative to the' \
' start of the line where the left curly brace is.',
'Indent the right brace the same as the start of the ' \
'line where the left brace is.'])
expect(cop.config_to_allow_offenses)
.to eq('EnforcedStyle' => 'align_braces')
end
it 'auto-corrects incorrectly indented first pair' do
corrected = autocorrect_source(cop, ['func({',
' a: 1',
'})'])
expect(corrected).to eq ['func({',
' a: 1',
' })'].join("\n")
end
it 'accepts special indentation for second argument' do
inspect_source(cop,
['body.should have_tag("input", :attributes => {',
' :name => /q\[(id_eq)\]/ })'])
expect(cop.offenses).to be_empty
end
it 'accepts normal indentation for hash within hash' do
inspect_source(cop,
['scope = scope.where(',
' klass.table_name => {',
' reflection.type => model.base_class.sti_name',
' }',
')'])
expect(cop.offenses).to be_empty
end
end
context 'and EnforcedStyle is consistent' do
let(:cop_config) { { 'EnforcedStyle' => 'consistent' } }
it 'accepts normal indentation for first argument' do
inspect_source(cop,
# Only the function calls are affected by
# EnforcedStyle setting. Other indentation shall be
# the same regardless of EnforcedStyle.
['h = {',
' a: 1',
'}',
'func({',
' a: 1',
'})',
'func(x, {',
' a: 1',
'})',
'h = { a: 1',
'}',
'func({ a: 1',
'})',
'func(x, { a: 1',
'})'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for incorrect indentation' do
inspect_source(cop,
['func({',
' a: 1',
' })'])
expect(cop.messages)
.to eq(['Use 2 spaces for indentation in a hash, relative to the' \
' start of the line where the left curly brace is.',
'Indent the right brace the same as the start of the ' \
'line where the left brace is.'])
expect(cop.config_to_allow_offenses)
.to eq('EnforcedStyle' => 'special_inside_parentheses')
end
it 'accepts normal indentation for second argument' do
inspect_source(cop,
['body.should have_tag("input", :attributes => {',
' :name => /q\[(id_eq)\]/ })'])
expect(cop.offenses).to be_empty
end
end
end
context 'and argument are not surrounded by parentheses' do
it 'accepts braceless hash' do
inspect_source(cop,
'func a: 1, b: 2')
expect(cop.offenses).to be_empty
end
it 'accepts single line hash with braces' do
inspect_source(cop,
'func x, { a: 1, b: 2 }')
expect(cop.offenses).to be_empty
end
it 'accepts a correctly indented multi-line hash with braces' do
inspect_source(cop,
['func x, {',
' a: 1, b: 2 }'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for incorrectly indented multi-line hash ' \
'with braces' do
inspect_source(cop,
['func x, {',
' a: 1, b: 2 }'])
expect(cop.messages)
.to eq(['Use 2 spaces for indentation in a hash, relative to the ' \
'start of the line where the left curly brace is.'])
expect(cop.highlights).to eq(['a: 1'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
end
end
context 'when EnforcedStyle is align_braces' do
let(:cop_config) { { 'EnforcedStyle' => 'align_braces' } }
it 'accepts correctly indented first pair' do
inspect_source(cop,
['a = {',
' a: 1',
' }'])
expect(cop.offenses).to be_empty
end
it 'accepts several pairs per line' do
inspect_source(cop,
['a = {',
' a: 1, b: 2',
' }'])
expect(cop.offenses).to be_empty
end
it 'accepts a first pair on the same line as the left brace' do
inspect_source(cop,
['a = { "a" => 1,',
' "b" => 2 }'])
expect(cop.offenses).to be_empty
end
it 'accepts single line hash' do
inspect_source(cop,
'a = { a: 1, b: 2 }')
expect(cop.offenses).to be_empty
end
it 'accepts an empty hash' do
inspect_source(cop,
'a = {}')
expect(cop.offenses).to be_empty
end
context "when 'consistent' style is used" do
it 'registers an offense for incorrect indentation' do
inspect_source(cop,
['func({',
' a: 1',
'})'])
expect(cop.messages)
.to eq(['Use 2 spaces for indentation in a hash, relative to the' \
' position of the opening brace.',
'Indent the right brace the same as the left brace.'])
expect(cop.config_to_allow_offenses)
.to eq('EnforcedStyle' => 'consistent')
end
it 'auto-corrects incorrectly indented first pair' do
corrected = autocorrect_source(cop, ['var = {',
' a: 1',
'}'])
expect(corrected).to eq ['var = {',
' a: 1',
' }'].join("\n")
end
end
context "when 'special_inside_parentheses' style is used" do
it 'registers an offense for incorrect indentation' do
inspect_source(cop,
['var = {',
' a: 1',
'}',
'func({',
' a: 1',
' })'])
expect(cop.messages)
.to eq(['Use 2 spaces for indentation in a hash, relative to the' \
' position of the opening brace.',
'Indent the right brace the same as the left brace.'])
expect(cop.config_to_allow_offenses)
.to eq('EnforcedStyle' => 'special_inside_parentheses')
end
end
it 'registers an offense for incorrectly indented }' do
inspect_source(cop,
['a << {',
' }'])
expect(cop.highlights).to eq(['}'])
expect(cop.messages)
.to eq(['Indent the right brace the same as the left brace.'])
expect(cop.config_to_allow_offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/indent_heredoc_spec.rb 0000664 0000000 0000000 00000017320 13070542236 0025775 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::IndentHeredoc, :config do
subject(:cop) { described_class.new(config) }
shared_examples :offense do |name, code, correction = nil|
it "registers an offense for #{name}" do
inspect_source(cop, code.strip_indent)
expect(cop.offenses.size).to eq(1)
end
it "autocorrects for #{name}" do
corrected = autocorrect_source_with_loop(cop, code.strip_indent)
expect(corrected).to eq(correction.strip_indent)
end
end
shared_examples :accept do |name, code|
it "accepts for #{name}" do
inspect_source(cop, code.strip_indent)
expect(cop.offenses).to be_empty
end
end
shared_examples :check_message do |name, message|
it "displays a message with #{name}" do
inspect_source(cop, <<-END.strip_indent)
<<-END2
foo
END2
END
expect(cop.messages).to eq(message)
end
end
shared_examples :warning do |message|
it 'warns' do
correct = lambda do
autocorrect_source(cop, <<-END.strip_indent)
<<-END2
foo
END2
END
end
expect(&correct).to raise_error(RuboCop::Warning, message)
end
end
shared_examples :all_heredoc_type do |quote|
context "quoted by #{quote}" do
let(:cop_config) do
{ 'EnforcedStyle' => :powerpack }
end
include_examples :offense, 'not indented', <<-END, <<-CORRECTION
<<#{quote}END2#{quote}
\#{foo}
bar
END2
END
<<#{quote}END2#{quote}.strip_indent
\#{foo}
bar
END2
CORRECTION
include_examples :offense, 'minus level indented', <<-END, <<-CORRECTION
def foo
<<#{quote}END2#{quote}
\#{foo}
bar
END2
end
END
def foo
<<#{quote}END2#{quote}.strip_indent
\#{foo}
bar
END2
end
CORRECTION
include_examples :offense, 'not indented, with `-`', <<-END, <<-CORRECTION
<<-#{quote}END2#{quote}
\#{foo}
bar
END2
END
<<-#{quote}END2#{quote}.strip_indent
\#{foo}
bar
END2
CORRECTION
include_examples :offense, 'minus level indented, with `-`',
<<-END, <<-CORRECTION
def foo
<<-#{quote}END2#{quote}
\#{foo}
bar
END2
end
END
def foo
<<-#{quote}END2#{quote}.strip_indent
\#{foo}
bar
END2
end
CORRECTION
include_examples :accept, 'not indented but with whitespace, with `-`',
<<-END
def foo
<<-#{quote}END2#{quote}
something
END2
end
END
include_examples :accept, 'indented, but with `-`', <<-END
def foo
<<-#{quote}END2#{quote}
something
END2
end
END
include_examples :accept, 'not indented but with whitespace', <<-END
def foo
<<#{quote}END2#{quote}
something
END2
end
END
include_examples :accept, 'indented, but without `~`', <<-END
def foo
<<#{quote}END2#{quote}
something
END2
end
END
include_examples :check_message, 'suggestion powerpack',
[
'Use 2 spaces for indentation in a heredoc by using ' \
'`String#strip_indent`.'
]
context 'EnforcedStyle is `auto_detection`' do
let(:cop_config) do
{ 'EnforcedStyle' => :auto_detection }
end
message = 'Use 2 spaces for indentation in a heredoc by using ' \
"some library(e.g. ActiveSupport's `String#strip_heredoc`)."
include_examples :check_message, 'some library', [message]
warning = 'Auto-correction does not work for Style/IndentHeredoc. ' \
'Please configure EnforcedStyle.'
include_examples :warning, warning
context 'Ruby 2.3', :ruby23 do
message = 'Use 2 spaces for indentation in a heredoc by using ' \
'`<<~` instead of `<<-`.'
include_examples :check_message, 'squiggly heredoc', [message]
include_examples :offense, 'not indented', <<-END, <<-CORRECTION
<<#{quote}END2#{quote}
\#{foo}
bar
END2
END
<<~#{quote}END2#{quote}
\#{foo}
bar
END2
CORRECTION
end
context 'Rails', :enabled_rails do
message = 'Use 2 spaces for indentation in a heredoc by using ' \
'`String#strip_heredoc`.'
include_examples :check_message, 'suggestion ActiveSupport', [message]
include_examples :offense, 'not indented', <<-END, <<-CORRECTION
<<#{quote}END2#{quote}
\#{foo}
bar
END2
END
<<#{quote}END2#{quote}.strip_heredoc
\#{foo}
bar
END2
CORRECTION
end
end
context 'EnforcedStyle is `squiggly`', :ruby23 do
let(:cop_config) do
{ 'EnforcedStyle' => :squiggly }
end
include_examples :offense, 'not indented', <<-END, <<-CORRECTION
<<~#{quote}END2#{quote}
something
END2
END
<<~#{quote}END2#{quote}
something
END2
CORRECTION
include_examples :offense, 'minus level indented', <<-END, <<-CORRECTION
def foo
<<~#{quote}END2#{quote}
something
END2
end
END
def foo
<<~#{quote}END2#{quote}
something
END2
end
CORRECTION
include_examples :offense, 'too deep indented', <<-END, <<-CORRECTION
<<~#{quote}END2#{quote}
something
END2
END
<<~#{quote}END2#{quote}
something
END2
CORRECTION
include_examples :offense, 'not indented, without `~`',
<<-END, <<-CORRECTION
<<#{quote}END2#{quote}
foo
END2
END
<<~#{quote}END2#{quote}
foo
END2
CORRECTION
include_examples :accept, 'indentaed, with `~`', <<-END
<<~#{quote}END2#{quote}
something
END2
END
include_examples :accept, 'include empty line', <<-END
<<~#{quote}MSG#{quote}
foo
bar
MSG
END
it 'displays message to use `<<~` instead of `<<`' do
inspect_source(cop, <<-END.strip_indent)
< 'normal' } }
context 'with if statement' do
it 'registers an offense for bad indentation in an if body' do
inspect_source(cop,
['if cond',
' func',
' func',
'end'])
expect(cop.messages).to eq(['Inconsistent indentation detected.'])
end
it 'registers an offense for bad indentation in an else body' do
inspect_source(cop,
['if cond',
' func1',
'else',
' func2',
' func2',
'end'])
expect(cop.messages).to eq(['Inconsistent indentation detected.'])
end
it 'registers an offense for bad indentation in an elsif body' do
inspect_source(cop,
['if a1',
' b1',
'elsif a2',
' b2',
'b3',
'else',
' c',
'end'])
expect(cop.messages).to eq(['Inconsistent indentation detected.'])
end
it 'autocorrects bad indentation' do
corrected = autocorrect_source(cop,
['if a1',
' b1',
'elsif a2',
' b2',
' b3',
'else',
' c',
'end'])
expect(corrected).to eq ['if a1',
' b1',
'elsif a2',
' b2',
' b3',
'else',
' c',
'end'].join("\n")
end
it 'accepts a one line if statement' do
inspect_source(cop, 'if cond then func1 else func2 end')
expect(cop.offenses).to be_empty
end
it 'accepts a correctly aligned if/elsif/else/end' do
inspect_source(cop,
['if a1',
' b1',
'elsif a2',
' b2',
'else',
' c',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts if/elsif/else/end laid out as a table' do
inspect_source(cop,
['if @io == $stdout then str << "$stdout"',
'elsif @io == $stdin then str << "$stdin"',
'elsif @io == $stderr then str << "$stderr"',
'else str << @io.class.to_s',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts if/then/else/end laid out as another table' do
inspect_source(cop,
["if File.exist?('config.save')",
'then ConfigTable.load',
'else ConfigTable.new',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts if/elsif/else/end with fullwidth characters' do
inspect_source(cop,
["p 'Ｒｕｂｙ', if a then b",
' c',
' end'])
expect(cop.offenses).to be_empty
end
it 'accepts an empty if' do
inspect_source(cop,
['if a',
'else',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts an if in assignment with end aligned with variable' do
inspect_source(cop,
['var = if a',
' 0',
'end',
'@var = if a',
' 0',
'end',
'$var = if a',
' 0',
'end',
'var ||= if a',
' 0',
'end',
'var &&= if a',
' 0',
'end',
'var -= if a',
' 0',
'end',
'VAR = if a',
' 0',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts an if/else in assignment with end aligned with variable' do
inspect_source(cop,
['var = if a',
' 0',
'else',
' 1',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts an if/else in assignment with end aligned with variable ' \
'and chaining after the end' do
inspect_source(cop,
['var = if a',
' 0',
'else',
' 1',
'end.abc.join("")'])
expect(cop.offenses).to be_empty
end
it 'accepts an if/else in assignment with end aligned with variable ' \
'and chaining with a block after the end' do
inspect_source(cop,
['var = if a',
' 0',
'else',
' 1',
'end.abc.tap {}'])
expect(cop.offenses).to be_empty
end
it 'accepts an if in assignment with end aligned with if' do
inspect_source(cop,
['var = if a',
' 0',
' end'])
expect(cop.offenses).to be_empty
end
it 'accepts an if/else in assignment with end aligned with if' do
inspect_source(cop,
['var = if a',
' 0',
' else',
' 1',
' end'])
expect(cop.offenses).to be_empty
end
it 'accepts an if/else in assignment on next line with end aligned ' \
'with if' do
inspect_source(cop,
['var =',
' if a',
' 0',
' else',
' 1',
' end'])
expect(cop.offenses).to be_empty
end
it 'accepts an if/else branches with rescue clauses' do
# Because of how the rescue clauses come out of Parser, these are
# special and need to be tested.
inspect_source(cop,
['if a',
' a rescue nil',
'else',
' a rescue nil',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with unless' do
it 'registers an offense for bad indentation in an unless body' do
inspect_source(cop,
['unless cond',
' func',
' func',
'end'])
expect(cop.messages).to eq(['Inconsistent indentation detected.'])
end
it 'accepts an empty unless' do
inspect_source(cop,
['unless a',
'else',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with case' do
it 'registers an offense for bad indentation in a case/when body' do
inspect_source(cop,
['case a',
'when b',
' c',
' d',
'end'])
expect(cop.messages).to eq(['Inconsistent indentation detected.'])
end
it 'registers an offense for bad indentation in a case/else body' do
inspect_source(cop,
['case a',
'when b',
' c',
'when d',
' e',
'else',
' f',
' g',
'end'])
expect(cop.messages).to eq(['Inconsistent indentation detected.'])
end
it 'accepts correctly indented case/when/else' do
inspect_source(cop,
['case a',
'when b',
' c',
' c',
'when d',
'else',
' f',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts case/when/else laid out as a table' do
inspect_source(cop,
['case sexp.loc.keyword.source',
"when 'if' then cond, body, _else = *sexp",
"when 'unless' then cond, _else, body = *sexp",
'else cond, body = *sexp',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts case/when/else with then beginning a line' do
inspect_source(cop,
['case sexp.loc.keyword.source',
"when 'if'",
'then cond, body, _else = *sexp',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts indented when/else plus indented body' do
# "Indent when as deep as case" is the job of another cop.
inspect_source(cop,
['case code_type',
" when 'ruby', 'sql', 'plain'",
' code_type',
" when 'erb'",
" 'ruby; html-script: true'",
' when "html"',
" 'xml'",
' else',
" 'plain'",
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with while/until' do
it 'registers an offense for bad indentation in a while body' do
inspect_source(cop,
['while cond',
' func',
' func',
'end'])
expect(cop.messages).to eq(['Inconsistent indentation detected.'])
end
it 'registers an offense for bad indentation in begin/end/while' do
inspect_source(cop,
['something = begin',
' func1',
' func2',
'end while cond'])
expect(cop.messages).to eq(['Inconsistent indentation detected.'])
end
it 'registers an offense for bad indentation in an until body' do
inspect_source(cop,
['until cond',
' func',
' func',
'end'])
expect(cop.messages).to eq(['Inconsistent indentation detected.'])
end
it 'accepts an empty while' do
inspect_source(cop,
['while a',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with for' do
it 'registers an offense for bad indentation in a for body' do
inspect_source(cop,
['for var in 1..10',
' func',
'func',
'end'])
expect(cop.messages).to eq(['Inconsistent indentation detected.'])
end
it 'accepts an empty for' do
inspect_source(cop,
['for var in 1..10',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with def/defs' do
it 'registers an offense for bad indentation in a def body' do
inspect_source(cop,
['def test',
' func1',
' func2',
'end'])
expect(cop.messages)
.to eq(['Inconsistent indentation detected.'])
end
it 'registers an offense for bad indentation in a defs body' do
inspect_source(cop,
['def self.test',
' func',
' func',
'end'])
expect(cop.messages).to eq(['Inconsistent indentation detected.'])
end
it 'accepts an empty def body' do
inspect_source(cop,
['def test',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts an empty defs body' do
inspect_source(cop,
['def self.test',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with class' do
context 'with rails style configured' do
let(:cop_config) { { 'EnforcedStyle' => 'rails' } }
it 'accepts different indentation in different visibility sections' do
inspect_source(cop,
['class Cat',
' def meow',
" puts('Meow!')",
' end',
'',
' protected',
'',
' def can_we_be_friends?(another_cat)',
' # some logic',
' end',
'',
' def related_to?(another_cat)',
' # some logic',
' end',
'',
' private',
'',
# Here we go back an indentation level again. This is a
# violation of the Rails style, but it's not for this
# cop to report. Style/IndentationWidth will handle it.
' def meow_at_3am?',
' rand < 0.8',
' end',
'',
# As long as the indentation of this method is
# consistent with that of the last one, we're fine.
' def meow_at_4am?',
' rand < 0.8',
' end',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with normal style configured' do
it 'registers an offense for bad indentation in a class body' do
inspect_source(cop,
['class Test',
' def func1',
' end',
' def func2',
' end',
'end'])
expect(cop.messages)
.to eq(['Inconsistent indentation detected.'])
end
it 'accepts an empty class body' do
inspect_source(cop,
['class Test',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts indented public, protected, and private' do
inspect_source(cop,
['class Test',
' public',
'',
' def e',
' end',
'',
' protected',
'',
' def f',
' end',
'',
' private',
'',
' def g',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for bad indentation in def but not for ' \
'outdented public, protected, and private' do
inspect_source(cop,
['class Test',
'public',
'',
' def e',
' end',
'',
'protected',
'',
' def f',
' end',
'',
'private',
'',
' def g',
' end',
'end'])
expect(cop.messages).to eq(['Inconsistent indentation detected.'])
expect(cop.highlights).to eq(["def g\n end"])
end
end
end
context 'with module' do
it 'registers an offense for bad indentation in a module body' do
inspect_source(cop,
['module Test',
' def func1',
' end',
' def func2',
' end',
'end'])
expect(cop.messages).to eq(['Inconsistent indentation detected.'])
end
it 'accepts an empty module body' do
inspect_source(cop,
['module Test',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with block' do
it 'registers an offense for bad indentation in a do/end body' do
inspect_source(cop,
['a = func do',
' b',
' c',
'end'])
expect(cop.messages).to eq(['Inconsistent indentation detected.'])
end
it 'registers an offense for bad indentation in a {} body' do
inspect_source(cop,
['func {',
' b',
' c',
'}'])
expect(cop.messages).to eq(['Inconsistent indentation detected.'])
end
it 'accepts a correctly indented block body' do
inspect_source(cop,
['a = func do',
' b',
' c',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts an empty block body' do
inspect_source(cop,
['a = func do',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not auto-correct an offense within another offense' do
corrected = autocorrect_source(cop,
["require 'spec_helper'",
'describe ArticlesController do',
' render_views',
' describe "GET \'index\'" do',
' it "returns success" do',
' end',
' describe "admin user" do',
' before(:each) do',
' end',
' end',
' end',
'end'])
expect(cop.offenses.map(&:line)).to eq [4, 7] # Two offenses are found.
# The offense on line 4 is corrected, affecting lines 4 to 11.
expect(corrected).to eq ["require 'spec_helper'",
'describe ArticlesController do',
' render_views',
" describe \"GET 'index'\" do",
' it "returns success" do',
' end',
' describe "admin user" do',
' before(:each) do',
' end',
' end',
' end',
'end'].join("\n")
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/indentation_width_spec.rb 0000664 0000000 0000000 00000123175 13070542236 0026544 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::IndentationWidth do
subject(:cop) { described_class.new(config) }
let(:config) do
RuboCop::Config.new('Style/IndentationWidth' => cop_config,
'Style/IndentationConsistency' => consistency_config,
'Lint/EndAlignment' => end_alignment_config,
'Lint/DefEndAlignment' => def_end_alignment_config)
end
let(:consistency_config) { { 'EnforcedStyle' => 'normal' } }
let(:end_alignment_config) do
{ 'Enabled' => true, 'EnforcedStyleAlignWith' => 'variable' }
end
let(:def_end_alignment_config) do
{ 'Enabled' => true, 'EnforcedStyleAlignWith' => 'start_of_line' }
end
context 'with Width set to 4' do
let(:cop_config) { { 'Width' => 4 } }
context 'for a file with byte order mark' do
let(:bom) { "\xef\xbb\xbf" }
it 'accepts correctly indented method definition' do
inspect_source(cop, ["#{bom}class Test",
' def method',
' end',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with ignored patterns set' do
let(:cop_config) do
{
'Width' => 4,
'IgnoredPatterns' => ['^\s*module', '^\s*(els)?if.*[A-Z][a-z]+']
}
end
it 'accepts unindented lines for those keywords' do
inspect_source(cop, ['module Foo',
'class Test',
' if blah',
' if blah == Apple',
'puts "sweet"',
' elsif blah == Lemon',
'puts "sour"',
' elsif blah == popcorn',
' puts "salty"',
' end',
' end',
'end',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with if statement' do
it 'registers an offense for bad indentation of an if body' do
inspect_source(cop,
['if cond',
' func',
'end'])
expect(cop.messages).to eq(['Use 4 (not 1) spaces for indentation.'])
expect(cop.highlights).to eq([' '])
end
end
describe '#autocorrect' do
it 'corrects bad indentation' do
corrected = autocorrect_source(cop,
['if a1',
' b1',
' b1',
'elsif a2',
' b2',
'else',
' c',
'end'])
expect(corrected)
.to eq ['if a1',
' b1',
' b1', # Will be corrected by IndentationConsistency.
'elsif a2',
' b2',
'else',
' c',
'end'].join("\n")
end
end
end
context 'with Width set to 2' do
let(:cop_config) { { 'Width' => 2 } }
context 'with if statement' do
it 'registers an offense for bad indentation of an if body' do
inspect_source(cop,
['if cond',
' func',
'end'])
expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
expect(cop.highlights).to eq([' '])
end
it 'registers an offense for bad indentation of an else body' do
inspect_source(cop,
['if cond',
' func1',
'else',
' func2',
'end'])
expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
expect(cop.highlights).to eq([' '])
end
it 'registers an offense for bad indentation of an elsif body' do
inspect_source(cop,
['if a1',
' b1',
'elsif a2',
' b2',
'else',
' c',
'end'])
expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
end
it 'registers offense for bad indentation of ternary inside else' do
inspect_source(cop,
['if a',
' b',
'else',
' x ? y : z',
'end'])
expect(cop.messages)
.to eq(['Use 2 (not 5) spaces for indentation.'])
expect(cop.highlights).to eq([' '])
end
it 'registers offense for bad indentation of modifier if in else' do
inspect_source(cop,
['if a',
' b',
'else',
' x if y',
'end'])
expect(cop.messages)
.to eq(['Use 2 (not 3) spaces for indentation.'])
end
it 'accepts indentation after if on new line after assignment' do
inspect_source(cop,
['Rails.application.config.ideal_postcodes_key =',
' if Rails.env.production? || Rails.env.staging?',
' "AAAA-AAAA-AAAA-AAAA"',
' end'])
expect(cop.offenses).to be_empty
end
it 'accepts `rescue` after an empty body' do
inspect_source(cop, ['begin',
'rescue',
' handle_error',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts `ensure` after an empty body' do
inspect_source(cop, ['begin',
'ensure',
' something',
'end'])
expect(cop.offenses).to be_empty
end
describe '#autocorrect' do
it 'corrects bad indentation' do
corrected = autocorrect_source(cop,
['if a1',
' b1',
' b1',
'elsif a2',
' b2',
'else',
' c',
'end'])
expect(corrected)
.to eq ['if a1',
' b1',
' b1', # Will be corrected by IndentationConsistency.
'elsif a2',
' b2',
'else',
' c',
'end'].join("\n")
end
it 'does not correct in scopes that contain block comments' do
corrected = autocorrect_source(cop,
['module Foo',
'class Bar',
'=begin',
'This is a nice long',
'comment',
'which spans a few lines',
'=end',
'def baz',
'do_something',
'end',
'end',
'end'])
expect(corrected).to eq ['module Foo',
# The class has a block comment within, so
# it's not corrected.
'class Bar',
'=begin',
'This is a nice long',
'comment',
'which spans a few lines',
'=end',
# The method has no block comment inside,
# but it's within a class that has a block
# comment, so it's not corrected either.
'def baz',
'do_something',
'end',
'end',
'end'].join("\n")
end
it 'does not indent heredoc strings' do
corrected = autocorrect_source(cop,
['module Foo',
'module Bar',
' SOMETHING = < attr,',
' :attr2 => Other.get_value(),',
' :attr3 => Another.get_value()) }']
corrected = autocorrect_source(cop, src)
expect(corrected).to eq src.join("\n")
end
it 'handles lines with only whitespace' do
corrected = autocorrect_source(cop, ['def x',
' y',
' ',
'rescue',
'end'])
expect(corrected).to eq ['def x',
' y',
' ',
'rescue',
'end'].join("\n")
end
end
it 'accepts a one line if statement' do
inspect_source(cop, 'if cond then func1 else func2 end')
expect(cop.offenses).to be_empty
end
it 'accepts a correctly aligned if/elsif/else/end' do
inspect_source(cop,
['if a1',
' b1',
'elsif a2',
' b2',
'else',
' c',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts a correctly aligned if/elsif/else/end as a method argument' do
inspect_source(cop,
['foo(',
' if a1',
' b1',
' elsif a2',
' b2',
' else',
' c',
' end',
')'])
expect(cop.offenses).to be_empty
end
it 'accepts if/elsif/else/end laid out as a table' do
inspect_source(cop,
['if @io == $stdout then str << "$stdout"',
'elsif @io == $stdin then str << "$stdin"',
'elsif @io == $stderr then str << "$stderr"',
'else str << @io.class.to_s',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts if/then/else/end laid out as another table' do
inspect_source(cop,
["if File.exist?('config.save')",
'then ConfigTable.load',
'else ConfigTable.new',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts an empty if' do
inspect_source(cop,
['if a',
'else',
'end'])
expect(cop.offenses).to be_empty
end
context 'with assignment' do
context 'when alignment style is variable' do
context 'and end is aligned with variable' do
it 'accepts an if with end aligned with setter' do
inspect_source(cop,
['foo.bar = if baz',
' derp',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts an if with end aligned with element assignment' do
inspect_source(cop,
['foo[bar] = if baz',
' derp',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts an if with end aligned with variable' do
inspect_source(cop,
['var = if a',
' 0',
'end',
'@var = if a',
' 0',
'end',
'$var = if a',
' 0',
'end',
'var ||= if a',
' 0',
'end',
'var &&= if a',
' 0',
'end',
'var -= if a',
' 0',
'end',
'VAR = if a',
' 0',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts an if/else' do
inspect_source(cop,
['var = if a',
' 0',
'else',
' 1',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts an if/else with chaining after the end' do
inspect_source(cop,
['var = if a',
' 0',
'else',
' 1',
'end.abc.join("")'])
expect(cop.offenses).to be_empty
end
it 'accepts an if/else with chaining with a block after the end' do
inspect_source(cop,
['var = if a',
' 0',
'else',
' 1',
'end.abc.tap {}'])
expect(cop.offenses).to be_empty
end
end
context 'and end is aligned with keyword' do
it 'registers an offense for an if with setter' do
inspect_source(cop,
['foo.bar = if baz',
' derp',
' end'])
expect(cop.messages)
.to eq(['Use 2 (not 12) spaces for indentation.'])
end
it 'registers an offense for an if with element assignment' do
inspect_source(cop,
['foo[bar] = if baz',
' derp',
' end'])
expect(cop.messages)
.to eq(['Use 2 (not 13) spaces for indentation.'])
end
it 'registers an offense for an if' do
inspect_source(cop,
['var = if a',
' 0',
' end'])
expect(cop.messages)
.to eq(['Use 2 (not 8) spaces for indentation.'])
end
it 'registers an offense for a while' do
inspect_source(cop,
['var = while a',
' b',
' end'])
expect(cop.messages)
.to eq(['Use 2 (not 8) spaces for indentation.'])
end
it 'registers an offense for an until' do
inspect_source(cop,
['var = until a',
' b',
' end'])
expect(cop.messages)
.to eq(['Use 2 (not 8) spaces for indentation.'])
end
end
context 'and end is aligned randomly' do
it 'registers an offense for an if' do
inspect_source(cop,
['var = if a',
' 0',
' end'])
expect(cop.messages)
.to eq(['Use 2 (not 10) spaces for indentation.'])
end
it 'registers an offense for a while' do
inspect_source(cop,
['var = while a',
' b',
' end'])
expect(cop.messages)
.to eq(['Use 2 (not 10) spaces for indentation.'])
end
it 'registers an offense for an until' do
inspect_source(cop,
['var = until a',
' b',
' end'])
expect(cop.messages)
.to eq(['Use 2 (not 10) spaces for indentation.'])
end
end
end
shared_examples 'assignment and if with keyword alignment' do
context 'and end is aligned with variable' do
it 'registers an offense for an if' do
inspect_source(cop,
['var = if a',
' 0',
'end'])
expect(cop.messages)
.to eq(['Use 2 (not -4) spaces for indentation.'])
end
it 'registers an offense for a while' do
inspect_source(cop,
['var = while a',
' b',
'end'])
expect(cop.messages)
.to eq(['Use 2 (not -4) spaces for indentation.'])
end
it 'autocorrects bad indentation' do
corrected = autocorrect_source(cop,
['var = if a',
' b',
'end',
'',
'var = while a',
' b',
'end'])
expect(corrected).to eq ['var = if a',
' b',
'end', # Not this cop's job to fix end.
'',
'var = while a',
' b',
'end'].join("\n")
end
end
context 'and end is aligned with keyword' do
it 'accepts an if in assignment' do
inspect_source(cop,
['var = if a',
' 0',
' end'])
expect(cop.offenses).to be_empty
end
it 'accepts an if/else in assignment' do
inspect_source(cop,
['var = if a',
' 0',
' else',
' 1',
' end'])
expect(cop.offenses).to be_empty
end
it 'accepts an if/else in assignment on next line' do
inspect_source(cop,
['var =',
' if a',
' 0',
' else',
' 1',
' end'])
expect(cop.offenses).to be_empty
end
it 'accepts a while in assignment' do
inspect_source(cop,
['var = while a',
' b',
' end'])
expect(cop.offenses).to be_empty
end
it 'accepts an until in assignment' do
inspect_source(cop,
['var = until a',
' b',
' end'])
expect(cop.offenses).to be_empty
end
end
end
context 'when alignment style is keyword by choice' do
let(:end_alignment_config) do
{ 'Enabled' => true, 'EnforcedStyleAlignWith' => 'keyword' }
end
include_examples 'assignment and if with keyword alignment'
end
end
it 'accepts an if/else branches with rescue clauses' do
# Because of how the rescue clauses come out of Parser, these are
# special and need to be tested.
inspect_source(cop,
['if a',
' a rescue nil',
'else',
' a rescue nil',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with unless' do
it 'registers an offense for bad indentation of an unless body' do
inspect_source(cop,
['unless cond',
' func',
'end'])
expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
end
it 'accepts an empty unless' do
inspect_source(cop,
['unless a',
'else',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with case' do
it 'registers an offense for bad indentation in a case/when body' do
inspect_source(cop,
['case a',
'when b',
' c',
'end'])
expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
end
it 'registers an offense for bad indentation in a case/else body' do
inspect_source(cop,
['case a',
'when b',
' c',
'when d',
' e',
'else',
' f',
'end'])
expect(cop.messages).to eq(['Use 2 (not 3) spaces for indentation.'])
end
it 'accepts correctly indented case/when/else' do
inspect_source(cop,
['case a',
'when b',
' c',
' c',
'when d',
'else',
' f',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts aligned values in when clause' do
inspect_source(cop,
['case superclass',
'when /\A(#{NAMESPACEMATCH})(?:\s|\Z)/,',
' /\A(Struct|OStruct)\.new/,',
' /\ADelegateClass\((.+?)\)\s*\Z/,',
' /\A(#{NAMESPACEMATCH})\(/',
' $1',
'when "self"',
' namespace.path',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts case/when/else laid out as a table' do
inspect_source(cop,
['case sexp.loc.keyword.source',
"when 'if' then cond, body, _else = *sexp",
"when 'unless' then cond, _else, body = *sexp",
'else cond, body = *sexp',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts case/when/else with then beginning a line' do
inspect_source(cop,
['case sexp.loc.keyword.source',
"when 'if'",
'then cond, body, _else = *sexp',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts indented when/else plus indented body' do
# "Indent when as deep as case" is the job of another cop.
inspect_source(cop,
['case code_type',
" when 'ruby', 'sql', 'plain'",
' code_type',
" when 'erb'",
" 'ruby; html-script: true'",
' when "html"',
" 'xml'",
' else',
" 'plain'",
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with while/until' do
it 'registers an offense for bad indentation of a while body' do
inspect_source(cop,
['while cond',
' func',
'end'])
expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
end
it 'registers an offense for bad indentation of begin/end/while' do
inspect_source(cop,
['something = begin',
' func1',
' func2',
'end while cond'])
expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
end
it 'registers an offense for bad indentation of an until body' do
inspect_source(cop,
['until cond',
' func',
'end'])
expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
end
it 'accepts an empty while' do
inspect_source(cop,
['while a',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with for' do
it 'registers an offense for bad indentation of a for body' do
inspect_source(cop,
['for var in 1..10',
' func',
'end'])
expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
end
it 'accepts an empty for' do
inspect_source(cop,
['for var in 1..10',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with def/defs' do
shared_examples 'without modifier on the same line' do
it 'registers an offense for bad indentation of a def body' do
inspect_source(cop,
['def test',
' func1',
' func2', # No offense registered for this.
'end'])
expect(cop.messages).to eq(['Use 2 (not 4) spaces for indentation.'])
end
it 'registers an offense for bad indentation of a defs body' do
inspect_source(cop,
['def self.test',
' func',
'end'])
expect(cop.messages).to eq(['Use 2 (not 3) spaces for indentation.'])
end
it 'accepts an empty def body' do
inspect_source(cop,
['def test',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts an empty defs body' do
inspect_source(cop,
['def self.test',
'end'])
expect(cop.offenses).to be_empty
end
it 'with an assignment' do
inspect_source(cop,
['something = def self.foo',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'when end is aligned with start of line' do
let(:def_end_alignment_config) do
{ 'Enabled' => true, 'EnforcedStyleAlignWith' => 'start_of_line' }
end
include_examples 'without modifier on the same line'
if RUBY_VERSION >= '2.1'
context 'when modifier and def are on the same line' do
it 'accepts a correctly aligned body' do
inspect_source(cop,
['foo def test',
' something',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for bad indentation of a def body' do
inspect_source(cop,
['foo def test',
' something',
' end'])
expect(cop.messages)
.to eq(['Use 2 (not 6) spaces for indentation.'])
end
it 'registers an offense for bad indentation of a defs body' do
inspect_source(cop,
['foo def self.test',
' something',
' end'])
expect(cop.messages)
.to eq(['Use 2 (not 6) spaces for indentation.'])
end
end
end
end
context 'when end is aligned with def' do
let(:def_end_alignment_config) do
{ 'Enabled' => true, 'EnforcedStyleAlignWith' => 'def' }
end
include_examples 'without modifier on the same line'
if RUBY_VERSION >= '2.1'
context 'when modifier and def are on the same line' do
it 'accepts a correctly aligned body' do
inspect_source(cop,
['foo def test',
' something',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for bad indentation of a def body' do
inspect_source(cop,
['foo def test',
' something',
' end'])
expect(cop.messages)
.to eq(['Use 2 (not -2) spaces for indentation.'])
end
it 'registers an offense for bad indentation of a defs body' do
inspect_source(cop,
['foo def self.test',
' something',
' end'])
expect(cop.messages)
.to eq(['Use 2 (not -2) spaces for indentation.'])
end
end
end
end
end
context 'with class' do
it 'registers an offense for bad indentation of a class body' do
inspect_source(cop,
['class Test',
' def func',
' end',
'end'])
expect(cop.messages).to eq(['Use 2 (not 4) spaces for indentation.'])
end
it 'accepts an empty class body' do
inspect_source(cop,
['class Test',
'end'])
expect(cop.offenses).to be_empty
end
context 'when consistency style is normal' do
it 'accepts indented public, protected, and private' do
inspect_source(cop,
['class Test',
' public',
'',
' def e',
' end',
'',
' protected',
'',
' def f',
' end',
'',
' private',
'',
' def g',
' end',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'when consistency style is rails' do
let(:consistency_config) { { 'EnforcedStyle' => 'rails' } }
it 'registers an offense for normal non-rails indentation' do
inspect_source(cop,
['class Test',
' public',
'',
' def e',
' end',
'',
' protected',
'',
' def f',
' end',
'',
' private',
'',
' def g',
' end',
'end'])
expect(cop.messages)
.to eq(['Use 2 (not 0) spaces for rails indentation.'] * 2)
expect(cop.offenses.map(&:line)).to eq([9, 14])
end
end
end
context 'with module' do
context 'when consistency style is normal' do
it 'registers an offense for bad indentation of a module body' do
inspect_source(cop,
['module Test',
' def func',
' end',
'end'])
expect(cop.messages).to eq(['Use 2 (not 4) spaces for indentation.'])
end
it 'accepts an empty module body' do
inspect_source(cop,
['module Test',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'when consistency style is rails' do
let(:consistency_config) { { 'EnforcedStyle' => 'rails' } }
it 'registers an offense for bad indentation of a module body' do
inspect_source(cop,
['module Test',
' def func1',
' end',
' private',
' def func2',
' end',
'end'])
expect(cop.messages)
.to eq(['Use 2 (not 3) spaces for indentation.',
'Use 2 (not -1) spaces for rails indentation.'])
end
it 'accepts normal non-rails indentation of module functions' do
inspect_source(cop,
['module Test',
' module_function',
' def func',
' end',
'end'])
expect(cop.offenses).to be_empty
end
end
end
context 'with begin/rescue/else/ensure/end' do
it 'registers an offense for bad indentation of bodies' do
inspect_source(cop,
['def my_func',
" puts 'do something outside block'",
' begin',
" puts 'do something error prone'",
' rescue SomeException, SomeOther => e',
" puts 'wrongly intended error handling'",
' rescue',
" puts 'wrongly intended error handling'",
' else',
" puts 'wrongly intended normal case handling'",
' ensure',
" puts 'wrongly intended common handling'",
' end',
'end'])
expect(cop.messages).to eq(['Use 2 (not 0) spaces for indentation.',
'Use 2 (not 1) spaces for indentation.',
'Use 2 (not 1) spaces for indentation.',
'Use 2 (not 3) spaces for indentation.',
'Use 2 (not 4) spaces for indentation.'])
end
end
context 'with def/rescue/end' do
it 'registers an offense for bad indentation of bodies' do
inspect_source(cop,
['def my_func',
" puts 'do something error prone'",
'rescue SomeException',
" puts 'wrongly intended error handling'",
'rescue',
" puts 'wrongly intended error handling'",
'end'])
expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.',
'Use 2 (not 1) spaces for indentation.'])
end
it 'registers an offense for bad indent of defs bodies with a modifier' do
inspect_source(cop,
['foo def self.my_func',
" puts 'do something error prone'",
'rescue SomeException',
" puts 'wrongly intended error handling'",
'rescue',
" puts 'wrongly intended error handling'",
'end'])
expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.',
'Use 2 (not 1) spaces for indentation.'])
end
end
context 'with block' do
context 'when consistency style is rails' do
let(:consistency_config) { { 'EnforcedStyle' => 'rails' } }
it 'registers an offense for bad indentation in a do/end body' do
inspect_source(cop,
['concern :Authenticatable do',
' def foo',
' puts "foo"',
' end',
'',
' private',
'',
' def bar',
' puts "bar"',
' end',
'end'])
expect(cop.messages)
.to eq(['Use 2 (not 0) spaces for rails indentation.'])
end
end
it 'registers an offense for bad indentation of a do/end body' do
inspect_source(cop,
['a = func do',
' b',
'end'])
expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
end
it 'registers an offense for bad indentation of a {} body' do
inspect_source(cop,
['func {',
' b',
'}'])
expect(cop.messages).to eq(['Use 2 (not 3) spaces for indentation.'])
end
it 'accepts a correctly indented block body' do
inspect_source(cop,
['a = func do',
' b',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts an empty block body' do
inspect_source(cop,
['a = func do',
'end'])
expect(cop.offenses).to be_empty
end
# The cop uses the block end/} as the base for indentation, so if it's not
# on its own line, all bets are off.
it 'accepts badly indented code if block end is not on separate line' do
inspect_source(cop,
['foo {',
'def baz',
'end }'])
expect(cop.offenses).to be_empty
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/infinite_loop_spec.rb 0000664 0000000 0000000 00000010234 13070542236 0025656 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::InfiniteLoop do
subject(:cop) { described_class.new(config) }
let(:config) do
RuboCop::Config.new('Style/IndentationWidth' => { 'Width' => 2 })
end
%w(1 2.0 [1] {}).each do |lit|
it "registers an offense for a while loop with #{lit} as condition" do
inspect_source(cop,
["while #{lit}",
' top',
'end'])
expect(cop.messages).to eq(['Use `Kernel#loop` for infinite loops.'])
expect(cop.highlights).to eq(['while'])
end
end
%w[false nil].each do |lit|
it "registers an offense for a until loop with #{lit} as condition" do
inspect_source(cop,
["until #{lit}",
' top',
'end'])
expect(cop.messages).to eq(['Use `Kernel#loop` for infinite loops.'])
expect(cop.highlights).to eq(['until'])
end
end
it 'accepts Kernel#loop' do
inspect_source(cop,
'loop { break if something }')
expect(cop.offenses).to be_empty
end
shared_examples_for 'auto-corrector' do |keyword, lit|
it "auto-corrects single line modifier #{keyword}" do
new_source =
autocorrect_source(cop, "something += 1 #{keyword} #{lit} # comment")
expect(new_source).to eq('loop { something += 1 } # comment')
end
context 'with non-default indentation width' do
let(:config) do
RuboCop::Config.new('Style/IndentationWidth' => { 'Width' => 4 })
end
it "auto-corrects multi-line modifier #{keyword} and indents correctly" do
new_source = autocorrect_source(cop, ['# comment',
'something 1, # comment 1',
' # comment 2',
" 2 #{keyword} #{lit}"])
expect(new_source).to eq(['# comment',
'loop do',
' something 1, # comment 1',
' # comment 2',
' 2',
'end'].join("\n"))
end
end
it "auto-corrects begin-end-#{keyword} with one statement" do
new_source = autocorrect_source(cop,
[' begin # comment 1',
' something += 1 # comment 2',
" end #{keyword} #{lit} # comment 3"])
expect(new_source).to eq([' loop do # comment 1',
' something += 1 # comment 2',
' end # comment 3'].join("\n"))
end
it "auto-corrects begin-end-#{keyword} with two statements" do
new_source = autocorrect_source(cop, [' begin',
' something += 1',
' something_else += 1',
" end #{keyword} #{lit}"])
expect(new_source).to eq([' loop do',
' something += 1',
' something_else += 1',
' end'].join("\n"))
end
it "auto-corrects single line modifier #{keyword} with and" do
new_source =
autocorrect_source(cop,
"something and something_else #{keyword} #{lit}")
expect(new_source).to eq('loop { something and something_else }')
end
it "auto-corrects the usage of #{keyword} with do" do
new_source = autocorrect_source(cop, ["#{keyword} #{lit} do",
'end'])
expect(new_source).to eq(['loop do',
'end'].join("\n"))
end
it "auto-corrects the usage of #{keyword} without do" do
new_source = autocorrect_source(cop, ["#{keyword} #{lit}",
'end'])
expect(new_source).to eq(['loop do',
'end'].join("\n"))
end
end
it_behaves_like 'auto-corrector', 'while', 'true'
it_behaves_like 'auto-corrector', 'until', 'false'
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/initial_indentation_spec.rb 0000664 0000000 0000000 00000004025 13070542236 0027046 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::InitialIndentation do
subject(:cop) { described_class.new }
it 'registers an offense for indented method definition ' do
inspect_source(cop, [' def f',
' end'])
expect(cop.messages).to eq(['Indentation of first line in file detected.'])
end
it 'accepts unindented method definition' do
inspect_source(cop, ['def f',
'end'])
expect(cop.offenses).to be_empty
end
context 'for a file with byte order mark' do
let(:bom) { "\xef\xbb\xbf" }
it 'accepts unindented method call' do
inspect_source(cop, bom + 'puts 1')
expect(cop.offenses).to be_empty
end
it 'registers an offense for indented method call' do
inspect_source(cop, bom + ' puts 1')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for indented method call after comment' do
inspect_source(cop, [bom + '# comment',
' puts 1'])
expect(cop.offenses.size).to eq(1)
end
end
it 'accepts empty file' do
inspect_source(cop, '')
expect(cop.offenses).to be_empty
end
it 'registers an offense for indented assignment disregarding comment' do
inspect_source(cop, [' # comment',
' x = 1'])
expect(cop.highlights).to eq(['x'])
end
it 'accepts unindented comment + assignment' do
inspect_source(cop, ['# comment',
'x = 1'])
expect(cop.offenses).to be_empty
end
it 'auto-corrects indented method definition' do
corrected = autocorrect_source(cop, [' def f',
' end'])
expect(corrected).to eq ['def f',
' end'].join("\n")
end
it 'auto-corrects indented assignment but not comment' do
corrected = autocorrect_source(cop, [' # comment',
' x = 1'])
expect(corrected).to eq [' # comment',
'x = 1'].join("\n")
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/inline_comment_spec.rb 0000664 0000000 0000000 00000001116 13070542236 0026017 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::InlineComment do
subject(:cop) { described_class.new }
it 'registers an offense for a trailing inline comment' do
inspect_source(cop, 'two = 1 + 1 # A trailing inline comment')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Avoid trailing inline comments.'])
expect(cop.highlights).to eq(['# A trailing inline comment'])
end
it 'does not register an offense for a standalone comment' do
inspect_source(cop, '# A standalone comment')
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/inverse_methods_spec.rb 0000664 0000000 0000000 00000020232 13070542236 0026215 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::InverseMethods do
let(:config) do
RuboCop::Config.new(
'Style/InverseMethods' => {
'InverseMethods' => {
any?: :none?,
even?: :odd?,
present?: :blank?,
include?: :exclude?,
:== => :!=,
:=~ => :!~,
:< => :>=,
:> => :<=
},
'InverseBlocks' => {
select: :reject,
select!: :reject!
}
}
)
end
subject(:cop) { described_class.new(config) }
it 'registers an offense for calling !.none? with a symbol proc' do
inspect_source(cop, '!foo.none?(&:even?)')
expect(cop.messages).to eq(['Use `any?` instead of inverting `none?`.'])
expect(cop.highlights).to eq(['!foo.none?(&:even?)'])
end
it 'registers an offense for calling !.none? with a block' do
inspect_source(cop, '!foo.none? { |f| f.even? }')
expect(cop.messages).to eq(['Use `any?` instead of inverting `none?`.'])
expect(cop.highlights).to eq(['!foo.none? { |f| f.even? }'])
end
it 'allows a method call without a not' do
inspect_source(cop, 'foo.none?')
expect(cop.offenses).to be_empty
end
context 'auto-correct' do
it 'corrects !.none? wiht a symbol proc to any?' do
new_source = autocorrect_source(cop, '!foo.none?(&:even?)')
expect(new_source).to eq('foo.any?(&:even?)')
end
it 'corrects !.none? with a block to any?' do
new_source = autocorrect_source(cop, '!foo.none? { |f| f.even? }')
expect(new_source).to eq('foo.any? { |f| f.even? }')
end
end
shared_examples :all_variable_types do |variable|
it "registers an offense for calling !#{variable}.none?" do
inspect_source(cop, "!#{variable}.none?")
expect(cop.messages).to eq(['Use `any?` instead of inverting `none?`.'])
expect(cop.highlights).to eq(["!#{variable}.none?"])
end
it "registers an offense for calling not #{variable}.none?" do
inspect_source(cop, "not #{variable}.none?")
expect(cop.messages).to eq(['Use `any?` instead of inverting `none?`.'])
expect(cop.highlights).to eq(["not #{variable}.none?"])
end
it "corrects !#{variable}.none? to #{variable}.any?" do
new_source = autocorrect_source(cop, "!#{variable}.none?")
expect(new_source).to eq("#{variable}.any?")
end
it "corrects not #{variable}.none? to #{variable}.any?" do
new_source = autocorrect_source(cop, "not #{variable}.none?")
expect(new_source).to eq("#{variable}.any?")
end
end
it_behaves_like :all_variable_types, 'foo'
it_behaves_like :all_variable_types, '$foo'
it_behaves_like :all_variable_types, '@foo'
it_behaves_like :all_variable_types, '@@foo'
it_behaves_like :all_variable_types, 'FOO'
it_behaves_like :all_variable_types, 'FOO::BAR'
it_behaves_like :all_variable_types, 'foo["bar"]'
it_behaves_like :all_variable_types, 'foo.bar'
{ any?: :none?,
even?: :odd?,
present?: :blank?,
include?: :exclude?,
none?: :any?,
odd?: :even?,
blank?: :present?,
exclude?: :include? }.each do |method, inverse|
it "registers an offense for !foo.#{method}" do
inspect_source(cop, "!foo.#{method}")
expect(cop.messages)
.to eq(["Use `#{inverse}` instead of inverting `#{method}`."])
end
it "corrects #{method} to #{inverse}" do
new_source = autocorrect_source(cop, "!foo.#{method}")
expect(new_source).to eq("foo.#{inverse}")
end
end
{ :== => :!=,
:!= => :==,
:=~ => :!~,
:!~ => :=~,
:< => :>=,
:> => :<= }.each do |method, inverse|
it "registers an offense for !(foo #{method} bar)" do
inspect_source(cop, "!(foo #{method} bar)")
expect(cop.messages)
.to eq(["Use `#{inverse}` instead of inverting `#{method}`."])
end
it "registers an offense for not (foo #{method} bar)" do
inspect_source(cop, "not (foo #{method} bar)")
expect(cop.messages)
.to eq(["Use `#{inverse}` instead of inverting `#{method}`."])
end
it "corrects #{method} to #{inverse}" do
new_source = autocorrect_source(cop, "!(foo #{method} bar)")
expect(new_source).to eq("foo #{inverse} bar")
end
end
context 'inverse blocks' do
{ select: :reject,
reject: :select,
select!: :reject!,
reject!: :select! }.each do |method, inverse|
it "registers an offense for foo.#{method} { |e| !e }" do
inspect_source(cop, "foo.#{method} { |e| !e }")
expect(cop.messages)
.to eq(["Use `#{inverse}` instead of inverting `#{method}`."])
end
it 'registers an offense for a multiline method call where the last ' \
'method is inverted' do
inspect_source(cop, ["foo.#{method} do |e|",
' something',
' !e.bar',
'end'])
expect(cop.messages)
.to eq(["Use `#{inverse}` instead of inverting `#{method}`."])
end
it 'registers an offense for an inverted equality block' do
inspect_source(cop, "foo.#{method} { |e| e != 2 }")
expect(cop.messages)
.to eq(["Use `#{inverse}` instead of inverting `#{method}`."])
end
it 'registers an offense for a multiline inverted equality block' do
inspect_source(cop, ["foo.#{method} do |e|",
' something',
' something_else',
' e != 2',
'end'])
expect(cop.messages)
.to eq(["Use `#{inverse}` instead of inverting `#{method}`."])
end
it 'corrects a simple inverted block' do
new_source = autocorrect_source(cop, "foo.#{method} { |e| !e }")
expect(new_source).to eq("foo.#{inverse} { |e| e }")
end
it 'corrects an inverted method call' do
new_source = autocorrect_source(cop, "foo.#{method} { |e| !e.bar? }")
expect(new_source).to eq("foo.#{inverse} { |e| e.bar? }")
end
it 'corrects a complex inverted method call' do
source = "puts 1 if !foo.#{method} { |e| !e.bar? }"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("puts 1 if !foo.#{inverse} { |e| e.bar? }")
end
it 'corrects an inverted do end method call' do
new_source = autocorrect_source(cop, ["foo.#{method} do |e|",
' !e.bar',
'end'])
expect(new_source).to eq(["foo.#{inverse} do |e|",
' e.bar',
'end'].join("\n"))
end
it 'corrects a multiline method call where the last method is inverted' do
new_source = autocorrect_source(cop, ["foo.#{method} do |e|",
' something',
' something_else',
' !e.bar',
'end'])
expect(new_source).to eq(["foo.#{inverse} do |e|",
' something',
' something_else',
' e.bar',
'end'].join("\n"))
end
it 'corrects an offense for an inverted equality block' do
new_source = autocorrect_source(cop, "foo.#{method} { |e| e != 2 }")
expect(new_source).to eq("foo.#{inverse} { |e| e == 2 }")
end
it 'corrects an offense for a multiline inverted equality block' do
new_source = autocorrect_source(cop, ["foo.#{method} do |e|",
' something',
' something_else',
' e != 2',
'end'])
expect(new_source).to eq(["foo.#{inverse} do |e|",
' something',
' something_else',
' e == 2',
'end'].join("\n"))
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/lambda_call_spec.rb 0000664 0000000 0000000 00000003744 13070542236 0025243 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::LambdaCall, :config do
subject(:cop) { described_class.new(config) }
context 'when style is set to call' do
let(:cop_config) { { 'EnforcedStyle' => 'call' } }
it 'registers an offense for x.()' do
inspect_source(cop,
'x.(a, b)')
expect(cop.offenses.size).to eq(1)
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'braces')
end
it 'registers an offense for correct + opposite' do
inspect_source(cop,
['x.call(a, b)',
'x.(a, b)'])
expect(cop.offenses.size).to eq(1)
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'accepts x.call()' do
inspect_source(cop, 'x.call(a, b)')
expect(cop.offenses).to be_empty
end
it 'auto-corrects x.() to x.call()' do
new_source = autocorrect_source(cop, ['a.(x)'])
expect(new_source).to eq('a.call(x)')
end
end
context 'when style is set to braces' do
let(:cop_config) { { 'EnforcedStyle' => 'braces' } }
it 'registers an offense for x.call()' do
inspect_source(cop,
'x.call(a, b)')
expect(cop.offenses.size).to eq(1)
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'call')
end
it 'registers an offense for opposite + correct' do
inspect_source(cop,
['x.call(a, b)',
'x.(a, b)'])
expect(cop.offenses.size).to eq(1)
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'accepts x.()' do
inspect_source(cop, 'x.(a, b)')
expect(cop.offenses).to be_empty
end
it 'accepts a call without receiver' do
inspect_source(cop, 'call(a, b)')
expect(cop.offenses).to be_empty
end
it 'auto-corrects x.call() to x.()' do
new_source = autocorrect_source(cop, ['a.call(x)'])
expect(new_source).to eq('a.(x)')
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/lambda_spec.rb 0000664 0000000 0000000 00000026073 13070542236 0024250 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::Lambda, :config do
subject(:cop) { described_class.new(config) }
shared_examples 'registers an offense' do |message|
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq([message])
end
end
shared_examples 'auto-correct' do |expected|
it 'auto-corrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(expected)
end
end
shared_examples 'does not auto-correct' do
it 'does not autocorrect' do
expect(autocorrect_source(cop, source)).to eq(source.join("\n"))
expect(cop.offenses.map(&:corrected?)).to eq [false]
end
end
context 'with enforced `lambda` style' do
let(:cop_config) { { 'EnforcedStyle' => 'lambda' } }
context 'with a single line lambda literal' do
context 'with arguments' do
let(:source) { 'f = ->(x) { x }' }
it_behaves_like 'registers an offense',
'Use the `lambda` method for all lambdas.'
it_behaves_like 'auto-correct', 'f = lambda { |x| x }'
end
context 'without arguments' do
let(:source) { 'f = -> { x }' }
it_behaves_like 'registers an offense',
'Use the `lambda` method for all lambdas.'
it_behaves_like 'auto-correct', 'f = lambda { x }'
end
end
context 'with a multiline lambda literal' do
context 'with arguments' do
let(:source) do
['f = ->(x) do',
' x',
'end']
end
it_behaves_like 'registers an offense',
'Use the `lambda` method for all lambdas.'
it_behaves_like 'auto-correct', ['f = lambda do |x|',
' x',
'end'].join("\n")
end
context 'without arguments' do
let(:source) do
['f = -> do',
' x',
'end']
end
it_behaves_like 'registers an offense',
'Use the `lambda` method for all lambdas.'
it_behaves_like 'auto-correct', ['f = lambda do',
' x',
'end'].join("\n")
end
end
end
context 'with enforced `literal` style' do
let(:cop_config) { { 'EnforcedStyle' => 'literal' } }
context 'with a single line lambda method call' do
context 'with arguments' do
let(:source) { 'f = lambda { |x| x }' }
it_behaves_like 'registers an offense',
'Use the `-> { ... }` lambda literal syntax for ' \
'all lambdas.'
it_behaves_like 'auto-correct', 'f = ->(x) { x }'
end
context 'without arguments' do
let(:source) { 'f = lambda { x }' }
it_behaves_like 'registers an offense',
'Use the `-> { ... }` lambda literal syntax for ' \
'all lambdas.'
it_behaves_like 'auto-correct', 'f = -> { x }'
end
end
context 'with a multiline lambda method call' do
context 'with arguments' do
let(:source) do
['f = lambda do |x|',
' x',
'end']
end
it_behaves_like 'registers an offense',
'Use the `-> { ... }` lambda literal syntax for ' \
'all lambdas.'
it_behaves_like 'auto-correct', ['f = ->(x) do',
' x',
'end'].join("\n")
end
context 'without arguments' do
let(:source) do
['f = lambda do',
' x',
'end']
end
it_behaves_like 'registers an offense',
'Use the `-> { ... }` lambda literal syntax for ' \
'all lambdas.'
it_behaves_like 'auto-correct', ['f = -> do',
' x',
'end'].join("\n")
end
end
end
context 'with default `line_count_dependent` style' do
let(:cop_config) { { 'EnforcedStyle' => 'line_count_dependent' } }
context 'with a single line lambda method call' do
context 'with arguments' do
let(:source) { 'f = lambda { |x| x }' }
it_behaves_like 'registers an offense',
'Use the `-> { ... }` lambda literal syntax for ' \
'single line lambdas.'
it_behaves_like 'auto-correct', 'f = ->(x) { x }'
end
context 'without arguments' do
let(:source) { 'f = lambda { x }' }
it_behaves_like 'registers an offense',
'Use the `-> { ... }` lambda literal syntax for ' \
'single line lambdas.'
it_behaves_like 'auto-correct', 'f = -> { x }'
end
end
context 'with a multiline lambda method call' do
it 'does not register an offense' do
inspect_source(cop, ['l = lambda do |x|',
' x',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with a single line lambda literal' do
it 'does not register an offense' do
inspect_source(cop, ['lambda = ->(x) { x }',
'lambda.(1)'])
expect(cop.offenses).to be_empty
end
end
context 'with a multiline lambda literal' do
context 'with arguments' do
let(:source) do
['f = ->(x) do',
' x',
'end']
end
it_behaves_like 'registers an offense',
'Use the `lambda` method for multiline lambdas.'
it_behaves_like 'auto-correct', ['f = lambda do |x|',
' x',
'end'].join("\n")
end
context 'without arguments' do
let(:source) do
['f = -> do',
' x',
'end']
end
it_behaves_like 'registers an offense',
'Use the `lambda` method for multiline lambdas.'
it_behaves_like 'auto-correct', ['f = lambda do',
' x',
'end'].join("\n")
end
end
context 'unusual lack of spacing' do
# The lack of spacing shown here is valid ruby syntax,
# and can be the result of previous autocorrects re-writing
# a multi-line `->(x){ ... }` to `->(x)do ... end`.
# See rubocop/cop/style/block_delimiters.rb.
# Tests correction of an issue resulting in `lambdado` syntax errors.
context 'without any spacing' do
let(:source) do
['->(x)do',
' x',
'end']
end
it_behaves_like 'auto-correct', ['lambda do |x|',
' x',
'end'].join("\n")
end
context 'without spacing after arguments' do
let(:source) do
['-> (x)do',
' x',
'end']
end
it_behaves_like 'auto-correct', ['lambda do |x|',
' x',
'end'].join("\n")
end
context 'without spacing before arguments' do
let(:source) do
['->(x) do',
' x',
'end']
end
it_behaves_like 'auto-correct', ['lambda do |x|',
' x',
'end'].join("\n")
end
context 'with a multiline lambda literal' do
context 'with empty arguments' do
let(:source) do
['->()do',
' x',
'end']
end
it_behaves_like 'auto-correct', ['lambda do',
' x',
'end'].join("\n")
end
context 'with no arguments and bad spacing' do
let(:source) do
['-> ()do',
' x',
'end']
end
it_behaves_like 'auto-correct', ['lambda do',
' x',
'end'].join("\n")
end
context 'with no arguments and no spacing' do
let(:source) do
['->do',
' x',
'end']
end
it_behaves_like 'auto-correct', ['lambda do',
' x',
'end'].join("\n")
end
context 'without parentheses' do
let(:source) do
['-> hello do',
' puts hello',
'end']
end
it_behaves_like 'registers an offense',
'Use the `lambda` method for multiline lambdas.'
it_behaves_like 'auto-correct', ['lambda do |hello|',
' puts hello',
'end'].join("\n")
end
context 'with no parentheses and bad spacing' do
let(:source) do
['-> hello do',
' puts hello',
'end']
end
it_behaves_like 'registers an offense',
'Use the `lambda` method for multiline lambdas.'
it_behaves_like 'auto-correct', ['lambda do |hello|',
' puts hello',
'end'].join("\n")
end
context 'with no parentheses and many args' do
let(:source) do
['-> hello, user do',
' puts hello',
'end']
end
it_behaves_like 'registers an offense',
'Use the `lambda` method for multiline lambdas.'
it_behaves_like 'auto-correct', ['lambda do |hello, user|',
' puts hello',
'end'].join("\n")
end
end
end
context 'when calling a lambda method without a block' do
it 'does not register an offense' do
inspect_source(cop, 'l = lambda.test')
expect(cop.offenses).to be_empty
end
end
context 'with a multiline lambda literal as an argument' do
let(:source) do
['has_many :kittens, -> do',
' where(cats: Cat.young.where_values_hash)',
'end, source: cats']
end
it_behaves_like 'registers an offense',
'Use the `lambda` method for multiline lambdas.'
it_behaves_like 'does not auto-correct'
end
context 'with a multiline lambda literal as a keyword argument' do
let(:source) do
['has_many opt: -> do',
' where(cats: Cat.young.where_values_hash)',
'end']
end
it_behaves_like 'registers an offense',
'Use the `lambda` method for multiline lambdas.'
it_behaves_like 'does not auto-correct'
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/leading_comment_space_spec.rb 0000664 0000000 0000000 00000005632 13070542236 0027326 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::LeadingCommentSpace do
subject(:cop) { described_class.new }
it 'registers an offense for comment without leading space' do
inspect_source(cop, '#missing space')
expect(cop.offenses.size).to eq(1)
end
it 'does not register an offense for # followed by no text' do
inspect_source(cop, '#')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for more than one space' do
inspect_source(cop, '# heavily indented')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for more than one #' do
inspect_source(cop, '###### heavily indented')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for only #s' do
inspect_source(cop, '######')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for #! on first line' do
inspect_source(cop,
['#!/usr/bin/ruby',
'test'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for #! after the first line' do
inspect_source(cop, ['test',
'#!/usr/bin/ruby'])
expect(cop.offenses.size).to eq(1)
end
context 'file named config.ru' do
it 'does not register an offense for #\ on first line' do
inspect_source(cop,
['#\ -w -p 8765',
'test'],
'/some/dir/config.ru')
expect(cop.offenses).to be_empty
end
it 'registers an offense for #\ after the first line' do
inspect_source(cop,
['test',
'#\ -w -p 8765'],
'/some/dir/config.ru')
expect(cop.offenses.size).to eq(1)
end
end
context 'file not named config.ru' do
it 'registers an offense for #\ on first line' do
inspect_source(cop,
['#\ -w -p 8765',
'test'],
'/some/dir/test_case.rb')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for #\ after the first line' do
inspect_source(cop,
['test',
'#\ -w -p 8765'],
'/some/dir/test_case.rb')
expect(cop.offenses.size).to eq(1)
end
end
it 'accepts rdoc syntax' do
inspect_source(cop,
['#++',
'#--',
'#:nodoc:'])
expect(cop.offenses).to be_empty
end
it 'accepts sprockets directives' do
inspect_source(cop, '#= require_tree .')
expect(cop.offenses).to be_empty
end
it 'auto-corrects missing space' do
new_source = autocorrect_source(cop, '#comment')
expect(new_source).to eq('# comment')
end
it 'accepts =begin/=end comments' do
inspect_source(cop, ['=begin',
'#blahblah',
'=end'])
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/line_end_concatenation_spec.rb 0000664 0000000 0000000 00000015161 13070542236 0027506 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::LineEndConcatenation do
subject(:cop) { described_class.new }
it 'registers an offense for string concat at line end' do
inspect_source(cop,
['top = "test" +',
'"top"'])
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['+'])
end
it 'registers an offense for string concat with << at line end' do
inspect_source(cop,
['top = "test" <<',
'"top"'])
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['<<'])
end
it 'registers an offense for string concat with << and \ at line ends' do
inspect_source(cop,
['top = "test " \\',
'"foo" <<',
'"bar"'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for dynamic string concat at line end' do
inspect_source(cop,
['top = "test#{x}" +',
'"top"'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for dynamic string concat with << at line end' do
inspect_source(cop,
['top = "test#{x}" <<',
'"top"'])
expect(cop.offenses.size).to eq(1)
end
it 'registers multiple offenses when there are chained << methods' do
inspect_source(cop,
['top = "test#{x}" <<',
'"top" <<',
'"ubertop"'])
expect(cop.offenses.size).to eq(2)
end
it 'registers multiple offenses when there are chained concatenations' do
inspect_source(cop,
['top = "test#{x}" +',
'"top" +',
'"foo"'])
expect(cop.offenses.size).to eq(2)
end
it 'registers multiple offenses when there are chained concatenations' \
'combined with << calls' do
inspect_source(cop,
['top = "test#{x}" <<',
'"top" +',
'"foo" <<',
'"bar"'])
expect(cop.offenses.size).to eq(3)
end
it 'accepts string concat on the same line' do
inspect_source(cop,
'top = "test" + "top"')
expect(cop.offenses).to be_empty
end
it 'accepts string concat with a return value of method on a string' do
inspect_source(cop,
[
# What we want here is 'content ', not '
# content content content '.
'content_and_three_spaces = "content" +',
' " " * 3',
# Method call with dot on a string literal.
"a_thing = 'a ' +",
" 'gniht'.reverse",
# Formatting operator.
"output = 'value: ' +",
" '%d' % value",
# Index operator.
"'letter: ' +",
" 'abcdefghij'[ix]"
])
expect(cop.offenses).to be_empty
end
it 'accepts string concat with a return value of method on an interpolated ' \
'string' do
source = <<-END
x3a = 'x' +
"\#{'a' + "\#{3}"}".reverse
END
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'accepts string concat at line end when followed by comment' do
inspect_source(cop,
['top = "test" + # something',
'"top"'])
expect(cop.offenses).to be_empty
end
it 'accepts string concat at line end when followed by a comment line' do
inspect_source(cop,
['top = "test" +',
'# something',
'"top"'])
expect(cop.offenses).to be_empty
end
it 'accepts string concat at line end when % literals are involved' do
inspect_source(cop,
['top = %(test) +',
'"top"'])
expect(cop.offenses).to be_empty
end
it 'accepts string concat at line end for special strings like __FILE__' do
inspect_source(cop,
['top = __FILE__ +',
'"top"'])
expect(cop.offenses).to be_empty
end
it 'registers offenses only for the appropriate lines in chained concats' do
# only the last concatenation is an offense
inspect_source(cop,
['top = "test#{x}" + # comment',
'"foo" +',
'%(bar) +',
'"baz" +',
'"qux"'])
expect(cop.offenses.size).to eq(1)
end
it 'autocorrects in the simple case by replacing + with \\' do
corrected = autocorrect_source(cop,
['top = "test" +',
'"top"'])
expect(corrected).to eq ['top = "test" \\', '"top"'].join("\n")
end
# The "central auto-correction engine" can't handle intermediate states where
# the code has syntax errors, so it's important to fix the trailing
# whitespace in this cop.
it 'autocorrects a + with trailing whitespace to \\' do
corrected = autocorrect_source(cop,
['top = "test" + ',
'"top"'])
expect(corrected).to eq ['top = "test" \\', '"top"'].join("\n")
end
it 'autocorrects a + with \\ to just \\' do
corrected = autocorrect_source(cop,
['top = "test" + \\',
'"top"'])
expect(corrected).to eq ['top = "test" \\', '"top"'].join("\n")
end
it 'autocorrects for chained concatenations and << calls' do
corrected = autocorrect_source(cop,
['top = "test#{x}" <<',
'"top" +',
'"ubertop" <<',
'"foo"'])
expect(corrected).to eq ['top = "test#{x}" \\',
'"top" \\',
'"ubertop" \\',
'"foo"'].join("\n")
end
it 'autocorrects only the lines that should be autocorrected' do
corrected = autocorrect_source(cop,
['top = "test#{x}" <<',
'"top" + # comment',
'"foo" +',
'"bar" +',
'%(baz) +',
'"qux"'])
expect(corrected).to eq ['top = "test#{x}" \\',
'"top" + # comment',
'"foo" \\',
'"bar" +',
'%(baz) +',
'"qux"'].join("\n")
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/method_call_with_args_parentheses_spec.rb 0000664 0000000 0000000 00000006055 13070542236 0031751 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::MethodCallWithArgsParentheses, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) do
{ 'IgnoredMethods' => %w[puts] }
end
it 'accepts no parens in method call without args' do
inspect_source(cop, 'top.test')
expect(cop.offenses).to be_empty
end
it 'accepts parens in method call with args' do
inspect_source(cop, 'top.test(a, b)')
expect(cop.offenses).to be_empty
end
it 'register an offense for method call without parens' do
inspect_source(cop, 'top.test a, b')
expect(cop.offenses.size).to eq(1)
end
it 'register an offense for non-reciever method call without parens' do
inspect_source(cop, 'test a, b')
expect(cop.offenses.size).to eq(1)
end
it 'register an offense for methods starting with a capital without parens' do
inspect_source(cop, 'Test a, b')
expect(cop.offenses.size).to eq(1)
end
it 'register an offense for superclass call without parens' do
inspect_source(cop, 'super a')
expect(cop.offenses.size).to eq(1)
end
it 'register no offense for superclass call without args' do
inspect_source(cop, 'super')
expect(cop.offenses).to be_empty
end
it 'register no offense for yield without args' do
inspect_source(cop, 'yield')
expect(cop.offenses).to be_empty
end
it 'register no offense for superclass call with parens' do
inspect_source(cop, 'super(a)')
expect(cop.offenses).to be_empty
end
it 'register an offense for yield without parens' do
inspect_source(cop, 'yield a')
expect(cop.offenses.size).to eq(1)
end
it 'accepts no parens for operators' do
inspect_source(cop, 'top.test + a')
expect(cop.offenses).to be_empty
end
it 'accepts no parens for setter methods' do
inspect_source(cop, 'top.test = a')
expect(cop.offenses).to be_empty
end
it 'accepts no parens for unary operators' do
inspect_source(cop, '!test')
expect(cop.offenses).to be_empty
end
it 'auto-corrects call by adding needed braces' do
new_source = autocorrect_source(cop, 'top.test a')
expect(new_source).to eq('top.test(a)')
end
it 'auto-corrects superclass call by adding needed braces' do
new_source = autocorrect_source(cop, 'super a')
expect(new_source).to eq('super(a)')
end
it 'ignores method listed in IgnoredMethods' do
inspect_source(cop, 'puts :test')
expect(cop.offenses).to be_empty
end
context 'when inspecting macro methods' do
let(:cop_config) do
{ 'IgnoreMacros' => 'true' }
end
context 'in a class body' do
it 'does not register an offense' do
inspect_source(cop, [
'class Foo',
' bar :baz',
'end'
].join("\n"))
expect(cop.offenses).to be_empty
end
end
context 'in a module body' do
it 'does not register an offense' do
inspect_source(cop, [
'module Foo',
' bar :baz',
'end'
].join("\n"))
expect(cop.offenses).to be_empty
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/method_call_without_args_parentheses_spec.rb 0000664 0000000 0000000 00000006465 13070542236 0032506 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::MethodCallWithoutArgsParentheses do
subject(:cop) { described_class.new }
it 'registers an offense for parens in method call without args' do
inspect_source(cop, 'top.test()')
expect(cop.offenses.size).to eq(1)
end
it 'accepts parentheses for methods starting with an upcase letter' do
inspect_source(cop, 'Test()')
expect(cop.offenses).to be_empty
end
it 'accepts no parens in method call without args' do
inspect_source(cop, 'top.test')
expect(cop.offenses).to be_empty
end
it 'accepts parens in method call with args' do
inspect_source(cop, 'top.test(a)')
expect(cop.offenses).to be_empty
end
it 'accepts special lambda call syntax' do
# Style/LambdaCall checks for this syntax
inspect_source(cop, 'thing.()')
expect(cop.offenses).to be_empty
end
it 'accepts parens after not' do
inspect_source(cop, 'not(something)')
expect(cop.offenses).to be_empty
end
context 'assignment to a variable with the same name' do
it 'accepts parens in local variable assignment ' do
inspect_source(cop, 'test = test()')
expect(cop.offenses).to be_empty
end
it 'accepts parens in shorthand assignment' do
inspect_source(cop, 'test ||= test()')
expect(cop.offenses).to be_empty
end
it 'accepts parens in parallel assignment' do
inspect_source(cop, 'one, test = 1, test()')
expect(cop.offenses).to be_empty
end
it 'accepts parens in complex assignment' do
inspect_source(cop, ['test = begin',
' case a',
' when b',
' c = test() if d',
' end',
'end'])
expect(cop.offenses).to be_empty
end
end
it 'registers an offense for `obj.method ||= func()`' do
inspect_source(cop, 'obj.method ||= func()')
expect(cop.offenses.size).to eq 1
end
it 'registers an offense for `obj.method &&= func()`' do
inspect_source(cop, 'obj.method &&= func()')
expect(cop.offenses.size).to eq 1
end
it 'registers an offense for `obj.method += func()`' do
inspect_source(cop, 'obj.method += func()')
expect(cop.offenses.size).to eq 1
end
it 'auto-corrects by removing unneeded braces' do
new_source = autocorrect_source(cop, 'test()')
expect(new_source).to eq('test')
end
# These will be offenses for the EmptyLiteral cop. The autocorrect loop will
# handle that.
it 'auto-corrects calls that could be empty literals' do
original = ['Hash.new()',
'Array.new()',
'String.new()']
new_source = autocorrect_source(cop, original)
expect(new_source).to eq(['Hash.new',
'Array.new',
'String.new'].join("\n"))
end
context 'method call as argument' do
it 'accepts without parens' do
inspect_source(cop, '_a = c(d.e)')
expect(cop.offenses).to be_empty
end
it 'registers an offense with empty parens' do
inspect_source(cop, '_a = c(d())')
expect(cop.offenses.size).to eq 1
end
it 'registers an empty parens offense for multiple assignment' do
inspect_source(cop, '_a, _b, _c = d(e())')
expect(cop.offenses.size).to eq 1
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/method_called_on_do_end_block_spec.rb 0000664 0000000 0000000 00000003256 13070542236 0030770 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::MethodCalledOnDoEndBlock do
subject(:cop) { described_class.new }
context 'with a multi-line do..end block' do
it 'registers an offense for a chained call' do
inspect_source(cop, ['a do',
' b',
'end.c'])
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['end.c'])
end
it 'accepts it if there is no chained call' do
inspect_source(cop, ['a do',
' b',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts a chained block' do
inspect_source(cop, ['a do',
' b',
'end.c do',
' d',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with a single-line do..end block' do
it 'registers an offense for a chained call' do
inspect_source(cop, 'a do b end.c')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['end.c'])
end
it 'accepts a single-line do..end block with a chained block' do
inspect_source(cop, 'a do b end.c do d end')
expect(cop.offenses).to be_empty
end
end
context 'with a {} block' do
it 'accepts a multi-line block with a chained call' do
inspect_source(cop, ['a {',
' b',
'}.c'])
expect(cop.offenses).to be_empty
end
it 'accepts a single-line block with a chained call' do
inspect_source(cop, 'a { b }.c')
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/method_def_parentheses_spec.rb 0000664 0000000 0000000 00000012122 13070542236 0027515 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::MethodDefParentheses, :config do
subject(:cop) { described_class.new(config) }
context 'require_parentheses' do
let(:cop_config) { { 'EnforcedStyle' => 'require_parentheses' } }
it 'reports an offense for def with parameters but no parens' do
src = ['def func a, b',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' =>
'require_no_parentheses')
end
it 'reports an offense for correct + opposite' do
src = ['def func(a, b)',
'end',
'def func a, b',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'reports an offense for class def with parameters but no parens' do
src = ['def Test.func a, b',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'accepts def with no args and no parens' do
src = ['def func',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'auto-adds required parens for a def' do
new_source = autocorrect_source(cop, 'def test param; end')
expect(new_source).to eq('def test(param); end')
end
it 'auto-adds required parens for a defs' do
new_source = autocorrect_source(cop, 'def self.test param; end')
expect(new_source).to eq('def self.test(param); end')
end
it 'auto-adds required parens to argument lists on multiple lines' do
new_source = autocorrect_source(cop, ['def test one,', 'two', 'end'])
expect(new_source).to eq(['def test(one,',
'two)',
'end'].join("\n"))
end
end
shared_examples :no_parentheses do
# common to require_no_parentheses and
# require_no_parentheses_except_multiline
it 'reports an offense for def with parameters with parens' do
src = ['def func(a, b)',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' =>
'require_parentheses')
end
it 'accepts a def with parameters but no parens' do
src = ['def func a, b',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'reports an offense for opposite + correct' do
src = ['def func(a, b)',
'end',
'def func a, b',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'reports an offense for class def with parameters with parens' do
src = ['def Test.func(a, b)',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'accepts a class def with parameters with parens' do
src = ['def Test.func a, b',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'reports an offense for def with no args and parens' do
src = ['def func()',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'accepts def with no args and no parens' do
src = ['def func',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'auto-removes the parens' do
new_source = autocorrect_source(cop, 'def test(param); end')
expect(new_source).to eq('def test param; end')
end
it 'auto-removes the parens for defs' do
new_source = autocorrect_source(cop, 'def self.test(param); end')
expect(new_source).to eq('def self.test param; end')
end
end
context 'require_no_parentheses' do
let(:cop_config) { { 'EnforcedStyle' => 'require_no_parentheses' } }
it_behaves_like :no_parentheses
end
context 'require_no_parentheses_except_multiline' do
let(:cop_config) do
{ 'EnforcedStyle' => 'require_no_parentheses_except_multiline' }
end
context 'when args are all on a single line' do
it_behaves_like :no_parentheses
end
context 'when args span multiple lines' do
it 'reports an offense for correct + opposite' do
src = ['def func(a,',
' b)',
'end',
'def func a,',
' b',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'auto-adds required parens to argument lists on multiple lines' do
new_source = autocorrect_source(cop, ['def test one,', 'two', 'end'])
expect(new_source).to eq(['def test(one,',
'two)',
'end'].join("\n"))
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/method_missing_spec.rb 0000664 0000000 0000000 00000005606 13070542236 0026040 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::MethodMissing do
subject(:cop) { described_class.new }
before do
inspect_source(cop, source)
end
shared_examples 'code with offense' do |code|
let(:source) { code }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq([message])
end
end
shared_examples 'code without offense' do |code|
let(:source) { code }
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
describe 'when not implementing #respond_to_missing? or calling #super' do
let(:message) do
'When using `method_missing`, define `respond_to_missing?` and ' \
'fall back on `super`.'
end
it_behaves_like 'code with offense',
['class Test',
' def method_missing; end',
'end'].join("\n")
end
describe 'when not implementing #respond_to_missing?' do
let(:message) do
'When using `method_missing`, define `respond_to_missing?`.'
end
it_behaves_like 'code with offense',
['class Test',
' def method_missing',
' super',
' end',
'end'].join("\n")
end
describe 'when not calling #super' do
let(:message) do
'When using `method_missing`, fall back on `super`.'
end
it_behaves_like 'code with offense',
['class Test',
' def respond_to_missing?; end',
' def method_missing; end',
'end'].join("\n")
end
describe 'when implementing #respond_to_missing? and calling #super' do
context 'when implemented as instance methods' do
it_behaves_like 'code without offense',
['class Test',
' def respond_to_missing?; end',
' def method_missing',
' super',
' end',
'end'].join("\n")
end
context 'when implemented as class methods' do
it_behaves_like 'code without offense',
['class Test',
' def self.respond_to_missing?; end',
' def self.method_missing',
' super',
' end',
'end'].join("\n")
end
context 'when implemented with different scopes' do
let(:message) do
'When using `method_missing`, define `respond_to_missing?`.'
end
it_behaves_like 'code with offense',
['class Test',
' def respond_to_missing?; end',
' def self.method_missing',
' super',
' end',
'end'].join("\n")
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/method_name_spec.rb 0000664 0000000 0000000 00000014163 13070542236 0025305 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::MethodName, :config do
subject(:cop) { described_class.new(config) }
shared_examples 'never accepted' do
it 'registers an offense for mixed snake case and camel case' do
inspect_source(cop, ['def visit_Arel_Nodes_SelectStatement',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['visit_Arel_Nodes_SelectStatement'])
end
it 'registers an offense for capitalized camel case' do
inspect_source(cop, ['class MyClass',
' def MyMethod',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['MyMethod'])
end
it 'registers an offense for singleton upper case method without ' \
'corresponding class' do
inspect_source(cop, ['module Sequel',
' def self.Model(source)',
' end',
'end'])
expect(cop.highlights).to eq(['Model'])
end
end
shared_examples 'always accepted' do
it 'accepts one line methods' do
inspect_source(cop, "def body; '' end")
expect(cop.offenses).to be_empty
end
it 'accepts operator definitions' do
inspect_source(cop, ['def +(other)',
' # ...',
'end'])
expect(cop.offenses).to be_empty
end
%w[class module].each do |kind|
it "accepts class emitter method in a #{kind}" do
inspect_source(cop, ["#{kind} Sequel",
' def self.Model(source)',
' end',
'',
' class Model',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it "accepts class emitter method in a #{kind}, even when it is " \
'defined inside another method' do
inspect_source(cop, ['module DPN',
' module Flow',
' module BaseFlow',
' class Start',
' end',
' def self.included(base)',
' def base.Start(aws_env, *args)',
' end',
' end',
' end',
' end',
'end'])
expect(cop.offenses).to be_empty
end
end
end
context 'when configured for snake_case' do
let(:cop_config) { { 'EnforcedStyle' => 'snake_case' } }
it 'registers an offense for camel case in instance method name' do
inspect_source(cop, ['def myMethod',
' # ...',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['myMethod'])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' =>
'camelCase')
end
it 'registers an offense for opposite + correct' do
inspect_source(cop, ['def my_method',
'end',
'def myMethod',
'end'])
expect(cop.highlights).to eq(['myMethod'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'registers an offense for camel case in singleton method name' do
inspect_source(cop, ['def self.myMethod',
' # ...',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['myMethod'])
end
it 'accepts snake case in names' do
inspect_source(cop, ['def my_method',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for singleton camelCase method within class' do
inspect_source(cop, ['class Sequel',
' def self.fooBar',
' end',
'end'])
expect(cop.highlights).to eq(['fooBar'])
end
include_examples 'never accepted'
include_examples 'always accepted'
end
context 'when configured for camelCase' do
let(:cop_config) { { 'EnforcedStyle' => 'camelCase' } }
it 'accepts camel case in instance method name' do
inspect_source(cop, ['def myMethod',
' # ...',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts camel case in singleton method name' do
inspect_source(cop, ['def self.myMethod',
' # ...',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for snake case in names' do
inspect_source(cop, ['def my_method',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['my_method'])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' =>
'snake_case')
end
it 'registers an offense for correct + opposite' do
inspect_source(cop, ['def my_method',
'end',
'def myMethod',
'end'])
expect(cop.highlights).to eq(['my_method'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'registers an offense for singleton snake_case method within class' do
inspect_source(cop, ['class Sequel',
' def self.foo_bar',
' end',
'end'])
expect(cop.highlights).to eq(['foo_bar'])
end
include_examples 'always accepted'
include_examples 'never accepted'
end
context 'when configured with a bad value' do
let(:cop_config) { { 'EnforcedStyle' => 'other' } }
it 'fails' do
expect { inspect_source(cop, 'def a', 'end') }
.to raise_error(RuntimeError)
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/missing_else_spec.rb 0000664 0000000 0000000 00000052676 13070542236 0025521 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::MissingElse do
subject(:cop) { described_class.new(config) }
context 'UnlessElse enabled' do
let(:config) do
RuboCop::Config.new('Style/MissingElse' => {
'Enabled' => true,
'EnforcedStyle' => 'both',
'SupportedStyles' => %w[if case both]
},
'Style/UnlessElse' => { 'Enabled' => true })
end
context 'given an if-statement' do
context 'with a completely empty else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'if a; foo else end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause containing only the literal nil' do
it "doesn't register an offense" do
inspect_source(cop, 'if a; foo elsif b; bar else nil end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'if cond; foo else bar; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it 'registers an offense' do
inspect_source(cop, 'if cond; foo end')
expect(cop.messages)
.to eq(['`if` condition requires an `else`-clause.'])
end
end
end
context 'given an unless-statement' do
context 'with a completely empty else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo else end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause containing only the literal nil' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo else nil end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo else bar; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo end')
expect(cop.messages).to be_empty
end
end
end
context 'given a case statement' do
context 'with a completely empty else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo else end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause containing only the literal nil' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo; when b; bar; else nil end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo; else b; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it 'registers an offense' do
inspect_source(cop, 'case v; when a; foo; when b; bar; end')
expect(cop.messages)
.to eq(['`case` condition requires an `else`-clause.'])
end
end
end
end
context 'UnlessElse disabled' do
let(:config) do
RuboCop::Config.new('Style/MissingElse' => {
'Enabled' => true,
'EnforcedStyle' => 'both',
'SupportedStyles' => %w[if case both]
},
'Style/UnlessElse' => { 'Enabled' => false })
end
context 'given an if-statement' do
context 'with a completely empty else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'if a; foo else end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause containing only the literal nil' do
it "doesn't register an offense" do
inspect_source(cop, 'if a; foo elsif b; bar else nil end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'if cond; foo else bar; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it 'registers an offense' do
inspect_source(cop, 'if cond; foo end')
expect(cop.messages)
.to eq(['`if` condition requires an `else`-clause.'])
end
end
end
context 'given an unless-statement' do
context 'with a completely empty else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo else end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause containing only the literal nil' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo else nil end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo else bar; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it 'registers an offense' do
inspect_source(cop, 'unless cond; foo end')
expect(cop.messages)
.to eq(['`if` condition requires an `else`-clause.'])
end
end
end
context 'given a case statement' do
context 'with a completely empty else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo else end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause containing only the literal nil' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo; when b; bar; else nil end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo; else b; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it 'registers an offense' do
inspect_source(cop, 'case v; when a; foo; when b; bar; end')
expect(cop.messages)
.to eq(['`case` condition requires an `else`-clause.'])
end
end
end
end
context 'EmptyElse enabled and set to warn on empty' do
let(:config) do
styles = %w[if case both]
RuboCop::Config.new('Style/MissingElse' => {
'Enabled' => true,
'EnforcedStyle' => 'both',
'SupportedStyles' => styles
},
'Style/UnlessElse' => { 'Enabled' => false },
'Style/EmptyElse' => {
'Enabled' => true,
'EnforcedStyle' => 'empty',
'SupportedStyles' => %w[empty nil both]
})
end
context 'given an if-statement' do
context 'with a completely empty else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'if a; foo else end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause containing only the literal nil' do
it "doesn't register an offense" do
inspect_source(cop, 'if a; foo elsif b; bar else nil end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'if cond; foo else bar; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it 'registers an offense' do
inspect_source(cop, 'if cond; foo end')
msg = ['`if` condition requires an `else`-clause with `nil` in it.']
expect(cop.messages)
.to eq(msg)
end
it 'highlights' do
inspect_source(cop, 'if cond; foo end')
expect(cop.highlights).to eq(['if cond; foo end'])
end
end
end
context 'given an unless-statement' do
context 'with a completely empty else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo else end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause containing only the literal nil' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo else nil end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo else bar; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it 'registers an offense' do
inspect_source(cop, 'unless cond; foo end')
msg = ['`if` condition requires an `else`-clause with `nil` in it.']
expect(cop.messages)
.to eq(msg)
end
end
end
context 'given a case statement' do
context 'with a completely empty else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo else end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause containing only the literal nil' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo; when b; bar; else nil end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo; else b; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it 'registers an offense' do
inspect_source(cop, 'case v; when a; foo; when b; bar; end')
msg = ['`case` condition requires an `else`-clause with `nil` in it.']
expect(cop.messages)
.to eq(msg)
end
end
end
end
context 'EmptyElse enabled and set to warn on nil' do
let(:config) do
styles = %w[if case both]
RuboCop::Config.new('Style/MissingElse' => {
'Enabled' => true,
'EnforcedStyle' => 'both',
'SupportedStyles' => styles
},
'Style/UnlessElse' => { 'Enabled' => false },
'Style/EmptyElse' => {
'Enabled' => true,
'EnforcedStyle' => 'nil',
'SupportedStyles' => %w[empty nil both]
})
end
context 'given an if-statement' do
context 'with a completely empty else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'if a; foo else end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause containing only the literal nil' do
it "doesn't register an offense" do
inspect_source(cop, 'if a; foo elsif b; bar else nil end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'if cond; foo else bar; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it 'registers an offense' do
inspect_source(cop, 'if cond; foo end')
expect(cop.messages)
.to eq(['`if` condition requires an empty `else`-clause.'])
end
end
end
context 'given an unless-statement' do
context 'with a completely empty else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo else end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause containing only the literal nil' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo else nil end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo else bar; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it 'registers an offense' do
inspect_source(cop, 'unless cond; foo end')
expect(cop.messages)
.to eq(['`if` condition requires an empty `else`-clause.'])
end
end
end
context 'given a case statement' do
context 'with a completely empty else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo else end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause containing only the literal nil' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo; when b; bar; else nil end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo; else b; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it 'registers an offense' do
inspect_source(cop, 'case v; when a; foo; when b; bar; end')
expect(cop.messages)
.to eq(['`case` condition requires an empty `else`-clause.'])
end
end
end
end
context 'configured to warn only on empty if' do
let(:config) do
styles = %w[if case both]
RuboCop::Config.new('Style/MissingElse' => {
'Enabled' => true,
'EnforcedStyle' => 'if',
'SupportedStyles' => styles
},
'Style/UnlessElse' => { 'Enabled' => false },
'Style/EmptyElse' => {
'Enabled' => true,
'EnforcedStyle' => 'nil',
'SupportedStyles' => %w[empty nil both]
})
end
context 'given an if-statement' do
context 'with a completely empty else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'if a; foo else end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause containing only the literal nil' do
it "doesn't register an offense" do
inspect_source(cop, 'if a; foo elsif b; bar else nil end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'if cond; foo else bar; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it 'registers an offense' do
inspect_source(cop, 'if cond; foo end')
expect(cop.messages)
.to eq(['`if` condition requires an empty `else`-clause.'])
end
end
end
context 'given an unless-statement' do
context 'with a completely empty else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo else end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause containing only the literal nil' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo else nil end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo else bar; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it 'registers an offense' do
inspect_source(cop, 'unless cond; foo end')
expect(cop.messages)
.to eq(['`if` condition requires an empty `else`-clause.'])
end
end
end
context 'given a case statement' do
context 'with a completely empty else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo else end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause containing only the literal nil' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo; when b; bar; else nil end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo; else b; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo; when b; bar; end')
expect(cop.messages).to be_empty
end
end
end
end
context 'configured to warn only on empty case' do
let(:config) do
styles = %w[if case both]
RuboCop::Config.new('Style/MissingElse' => {
'Enabled' => true,
'EnforcedStyle' => 'case',
'SupportedStyles' => styles
},
'Style/UnlessElse' => { 'Enabled' => false },
'Style/EmptyElse' => {
'Enabled' => true,
'EnforcedStyle' => 'nil',
'SupportedStyles' => %w[empty nil both]
})
end
context 'given an if-statement' do
context 'with a completely empty else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'if a; foo else end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause containing only the literal nil' do
it "doesn't register an offense" do
inspect_source(cop, 'if a; foo elsif b; bar else nil end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'if cond; foo else bar; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'if cond; foo end')
expect(cop.messages).to be_empty
end
end
end
context 'given an unless-statement' do
context 'with a completely empty else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo else end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause containing only the literal nil' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo else nil end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo else bar; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'unless cond; foo end')
expect(cop.messages).to be_empty
end
end
end
context 'given a case statement' do
context 'with a completely empty else-clause' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo else end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause containing only the literal nil' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo; when b; bar; else nil end')
expect(cop.messages).to be_empty
end
end
context 'with an else-clause with side-effects' do
it "doesn't register an offense" do
inspect_source(cop, 'case v; when a; foo; else b; nil end')
expect(cop.messages).to be_empty
end
end
context 'with no else-clause' do
it 'registers an offense' do
inspect_source(cop, 'case v; when a; foo; when b; bar; end')
expect(cop.messages)
.to eq(['`case` condition requires an empty `else`-clause.'])
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/mixin_grouping_spec.rb 0000664 0000000 0000000 00000015572 13070542236 0026070 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::MixinGrouping, :config do
subject(:cop) { described_class.new(config) }
before do
inspect_source(cop, source)
end
shared_examples 'code with offense' do |code, expected|
context "when checking #{code}" do
let(:source) { code }
it 'registers an offense' do
expect(cop.offenses.size).to eq(offenses)
expect(cop.messages).to eq([message] * offenses)
end
if expected
it 'auto-corrects' do
expect(autocorrect_source(cop, code)).to eq(expected)
end
else
it 'does not auto-correct' do
expect(autocorrect_source(cop, code)).to eq(code)
end
end
end
end
shared_examples 'code without offense' do |code|
let(:source) { code }
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
context 'when configured with separated style' do
let(:cop_config) { { 'EnforcedStyle' => 'separated' } }
let(:offenses) { 1 }
context 'when using `include`' do
let(:message) { 'Put `include` mixins in separate statements.' }
context 'with several mixins in one call' do
it_behaves_like 'code with offense',
['class Foo',
' include Bar, Qux',
'end'].join("\n")
end
context 'with several mixins in separate calls' do
it_behaves_like 'code without offense',
['class Foo',
' include Bar',
' include Qux',
'end'].join("\n")
end
context 'when include call is an argument to another method' do
it_behaves_like 'code without offense',
'expect(foo).to include(bar, baz)'
end
end
context 'when using `extend`' do
let(:message) { 'Put `extend` mixins in separate statements.' }
context 'with several mixins in one call' do
it_behaves_like 'code with offense',
['class Foo',
' extend Bar, Qux',
'end'].join("\n")
end
context 'with several mixins in separate calls' do
it_behaves_like 'code without offense',
['class Foo',
' extend Bar',
' extend Qux',
'end'].join("\n")
end
end
context 'when using `prepend`' do
let(:message) { 'Put `prepend` mixins in separate statements.' }
context 'with several mixins in one call' do
it_behaves_like 'code with offense',
['class Foo',
' prepend Bar, Qux',
'end'].join("\n")
end
context 'with several mixins in separate calls' do
it_behaves_like 'code without offense',
['class Foo',
' prepend Bar',
' prepend Qux',
'end'].join("\n")
end
end
context 'when using a mix of diffent methods' do
context 'with some calls having several mixins' do
let(:message) { 'Put `include` mixins in separate statements.' }
it_behaves_like 'code with offense',
['class Foo',
' include Bar, Baz',
' extend Qux',
'end'].join("\n")
end
context 'with all calls having one mixin' do
it_behaves_like 'code without offense',
['class Foo',
' include Bar',
' prepend Baz',
' extend Baz',
'end'].join("\n")
end
end
end
context 'when configured with grouped style' do
let(:cop_config) { { 'EnforcedStyle' => 'grouped' } }
context 'when using include' do
context 'with several mixins in one call' do
let(:offenses) { 3 }
let(:message) { 'Put `include` mixins in a single statement.' }
it_behaves_like 'code with offense',
['class Foo',
' include Bar',
' include Baz',
' include Qux',
'end'].join("\n")
end
context 'with several mixins in separate calls' do
it_behaves_like 'code without offense',
['class Foo',
' include Bar, Qux',
'end'].join("\n")
end
context 'when include has an explicit receiver' do
it_behaves_like 'code without offense',
['config.include Foo',
'config.include Bar'].join("\n")
end
end
context 'when using `extend`' do
context 'with several mixins in one call' do
let(:offenses) { 2 }
let(:message) { 'Put `extend` mixins in a single statement.' }
it_behaves_like 'code with offense',
['class Foo',
' extend Bar',
' extend Baz',
'end'].join("\n")
end
context 'with several mixins in separate calls' do
it_behaves_like 'code without offense',
['class Foo',
' extend Bar, Qux',
'end'].join("\n")
end
end
context 'when using `prepend`' do
context 'with several mixins in one call' do
let(:offenses) { 2 }
let(:message) { 'Put `prepend` mixins in a single statement.' }
it_behaves_like 'code with offense',
['class Foo',
' prepend Bar',
' prepend Baz',
'end'].join("\n")
end
context 'with several mixins in separate calls' do
it_behaves_like 'code without offense',
['class Foo',
' prepend Bar, Qux',
'end'].join("\n")
end
end
context 'when using a mix of diffent methods' do
context 'with some duplicated mixin methods' do
let(:offenses) { 2 }
let(:message) { 'Put `include` mixins in a single statement.' }
it_behaves_like 'code with offense',
['class Foo',
' include Bar',
' include Baz',
' extend Baz',
'end'].join("\n")
end
context 'with all different mixin methods' do
it_behaves_like 'code without offense',
['class Foo',
' include Bar',
' prepend Baz',
' extend Baz',
'end'].join("\n")
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/module_function_spec.rb 0000664 0000000 0000000 00000003166 13070542236 0026220 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::ModuleFunction, :config do
subject(:cop) { described_class.new(config) }
context 'when enforced style is `module_function`' do
let(:cop_config) { { 'EnforcedStyle' => 'module_function' } }
it 'registers an offense for `extend self` in a module' do
inspect_source(cop,
['module Test',
' extend self',
' def test; end',
'end'])
expect(cop.messages).to eq([described_class::MODULE_FUNCTION_MSG])
expect(cop.highlights).to eq(['extend self'])
end
it 'accepts `extend self` in a class' do
inspect_source(cop,
['class Test',
' extend self',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'when enforced style is `extend_self`' do
let(:cop_config) { { 'EnforcedStyle' => 'extend_self' } }
it 'registers an offense for `module_function` without an argument' do
inspect_source(cop,
['module Test',
' module_function',
' def test; end',
'end'])
expect(cop.messages).to eq([described_class::EXTEND_SELF_MSG])
expect(cop.highlights).to eq(['module_function'])
end
it 'accepts module_function with an argument' do
inspect_source(cop,
['module Test',
' def test; end',
' module_function :test',
'end'])
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/multiline_array_brace_layout_spec.rb 0000664 0000000 0000000 00000001460 13070542236 0030752 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::MultilineArrayBraceLayout, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'EnforcedStyle' => 'symmetrical' } }
it 'ignores implicit arrays' do
inspect_source(cop, ['foo = a,',
'b'])
expect(cop.offenses).to be_empty
end
it 'ignores single-line arrays' do
inspect_source(cop, '[a, b, c]')
expect(cop.offenses).to be_empty
end
it 'ignores empty arrays' do
inspect_source(cop, '[]')
expect(cop.offenses).to be_empty
end
include_examples 'multiline literal brace layout' do
let(:open) { '[' }
let(:close) { ']' }
end
include_examples 'multiline literal brace layout trailing comma' do
let(:open) { '[' }
let(:close) { ']' }
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/multiline_assignment_layout_spec.rb 0000664 0000000 0000000 00000010224 13070542236 0030646 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::MultilineAssignmentLayout, :config do
subject(:cop) { described_class.new(config) }
let(:supported_types) { %w[if] }
let(:cop_config) do
{
'EnforcedStyle' => enforced_style,
'SupportedTypes' => supported_types
}
end
context 'new_line style' do
let(:enforced_style) { 'new_line' }
it 'registers an offense when the rhs is on the same line' do
inspect_source(cop, ['blarg = if true',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(["blarg = if true\nend"])
expect(cop.messages).to eq([described_class::NEW_LINE_OFFENSE])
end
it 'auto-corrects offenses' do
new_source = autocorrect_source(cop, ['blarg = if true',
'end'])
expect(new_source).to eq("blarg =\n if true\nend")
end
it 'ignores arrays' do
inspect_source(cop, ['a, b = 4,',
'5'])
expect(cop.offenses).to be_empty
end
context 'configured supported types' do
let(:supported_types) { %w[array] }
it 'allows supported types to be configured' do
inspect_source(cop, ['a, b = 4,',
'5'])
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(["a, b = 4,\n5"])
expect(cop.messages).to eq([described_class::NEW_LINE_OFFENSE])
end
end
it 'allows multi-line assignments on separate lines' do
inspect_source(cop, ['blarg=',
'if true',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for masgn with multi-line lhs' do
inspect_source(cop, ['a,',
'b = if foo',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(["a,\nb = if foo\nend"])
expect(cop.messages).to eq([described_class::NEW_LINE_OFFENSE])
end
end
context 'same_line style' do
let(:enforced_style) { 'same_line' }
it 'registers an offense when the rhs is a different line' do
inspect_source(cop, ['blarg =',
'if true',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(["blarg =\nif true\nend"])
expect(cop.messages).to eq([described_class::SAME_LINE_OFFENSE])
end
it 'auto-corrects offenses' do
new_source = autocorrect_source(cop, ['blarg =',
'if true',
'end'])
expect(new_source).to eq("blarg = if true\nend")
end
it 'ignores arrays' do
inspect_source(cop, ['a, b =',
'4,',
'5'])
expect(cop.offenses).to be_empty
end
context 'configured supported types' do
let(:supported_types) { %w[array] }
it 'allows supported types to be configured' do
inspect_source(cop, ['a, b =',
'4,',
'5'])
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(["a, b =\n4,\n5"])
expect(cop.messages).to eq([described_class::SAME_LINE_OFFENSE])
end
end
it 'allows multi-line assignments on the same line' do
inspect_source(cop, ['blarg= if true',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for masgn with multi-line lhs' do
inspect_source(cop, ['a,',
'b =',
'if foo',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line).to eq(1)
expect(cop.highlights).to eq(["a,\nb =\nif foo\nend"])
expect(cop.messages).to eq([described_class::SAME_LINE_OFFENSE])
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/multiline_block_chain_spec.rb 0000664 0000000 0000000 00000004743 13070542236 0027346 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::MultilineBlockChain do
subject(:cop) { described_class.new }
context 'with multi-line block chaining' do
it 'registers an offense for a simple case' do
inspect_source(cop, ['a do',
' b',
'end.c do',
' d',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['end.c'])
end
it 'registers an offense for a slightly more complicated case' do
inspect_source(cop, ['a do',
' b',
'end.c1.c2 do',
' d',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['end.c1.c2'])
end
it 'registers two offenses for a chain of three blocks' do
inspect_source(cop, ['a do',
' b',
'end.c do',
' d',
'end.e do',
' f',
'end'])
expect(cop.offenses.size).to eq(2)
expect(cop.highlights).to eq(['end.c', 'end.e'])
end
it 'registers an offense for a chain where the second block is ' \
'single-line' do
inspect_source(cop, ['Thread.list.find_all { |t|',
' t.alive?',
'}.map { |thread| thread.object_id }'])
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['}.map'])
end
it 'accepts a chain where the first block is single-line' do
inspect_source(cop,
['Thread.list.find_all { |t| t.alive? }.map { |t| ',
' t.object_id',
'}'])
expect(cop.offenses).to be_empty
end
end
it 'accepts a chain of blocks spanning one line' do
inspect_source(cop, ['a { b }.c { d }',
'w do x end.y do z end'])
expect(cop.offenses).to be_empty
end
it 'accepts a multi-line block chained with calls on one line' do
inspect_source(cop, ['a do',
' b',
'end.c.d'])
expect(cop.offenses).to be_empty
end
it 'accepts a chain of calls followed by a multi-line block' do
inspect_source(cop, ['a1.a2.a3 do',
' b',
'end'])
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/multiline_block_layout_spec.rb 0000664 0000000 0000000 00000016235 13070542236 0027600 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::MultilineBlockLayout do
subject(:cop) { described_class.new }
it 'registers an offense for missing newline in do/end block w/o params' do
inspect_source(cop,
['test do foo',
'end'])
expect(cop.messages)
.to eq(['Block body expression is on the same line as the block start.'])
end
it 'registers an offense for missing newline in {} block w/o params' do
inspect_source(cop,
['test { foo',
'}'])
expect(cop.messages)
.to eq(['Block body expression is on the same line as the block start.'])
end
it 'registers an offense for missing newline in do/end block with params' do
inspect_source(cop,
['test do |x| foo',
'end'])
expect(cop.messages)
.to eq(['Block body expression is on the same line as the block start.'])
end
it 'registers an offense for missing newline in {} block with params' do
inspect_source(cop,
['test { |x| foo',
'}'])
expect(cop.messages)
.to eq(['Block body expression is on the same line as the block start.'])
end
it 'does not register an offense for one-line do/end blocks' do
inspect_source(cop, 'test do foo end')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for one-line {} blocks' do
inspect_source(cop, 'test { foo }')
expect(cop.offenses).to be_empty
end
it 'does not register offenses when there is a newline for do/end block' do
inspect_source(cop,
['test do',
' foo',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not error out when the block is empty' do
inspect_source(cop,
['test do |x|',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register offenses when there is a newline for {} block' do
inspect_source(cop,
['test {',
' foo',
'}'])
expect(cop.offenses).to be_empty
end
it 'registers offenses for lambdas as expected' do
inspect_source(cop,
['-> (x) do foo',
' bar',
'end'])
expect(cop.messages)
.to eq(['Block body expression is on the same line as the block start.'])
end
it 'registers offenses for new lambda literal syntax as expected' do
inspect_source(cop,
['-> x do foo',
' bar',
'end'])
expect(cop.messages)
.to eq(['Block body expression is on the same line as the block start.'])
end
it 'registers an offense for line-break before arguments' do
inspect_source(cop,
['test do',
' |x| play_with(x)',
'end'])
expect(cop.messages)
.to eq(['Block argument expression is not on the same line as the ' \
'block start.'])
end
it 'registers an offense for line-break before arguments with empty block' do
inspect_source(cop,
['test do',
' |x|',
'end'])
expect(cop.messages)
.to eq(['Block argument expression is not on the same line as the ' \
'block start.'])
end
it 'registers an offense for line-break within arguments' do
inspect_source(cop,
['test do |x,',
' y|',
'end'])
expect(cop.messages)
.to eq(['Block argument expression is not on the same line as the ' \
'block start.'])
end
it 'auto-corrects a do/end block with params that is missing newlines' do
src = ['test do |foo| bar',
'end']
new_source = autocorrect_source(cop, src)
expect(new_source).to eq(['test do |foo| ',
' bar',
'end'].join("\n"))
end
it 'auto-corrects a do/end block with a mult-line body' do
src = ['test do |foo| bar',
' test',
'end']
new_source = autocorrect_source(cop, src)
expect(new_source).to eq(['test do |foo| ',
' bar',
' test',
'end'].join("\n"))
end
it 'auto-corrects a {} block with params that is missing newlines' do
src = ['test { |foo| bar',
'}']
new_source = autocorrect_source(cop, src)
expect(new_source).to eq(['test { |foo| ',
' bar',
'}'].join("\n"))
end
it 'autocorrects in more complex case with lambda and assignment, and '\
'aligns the next line two spaces out from the start of the block' do
src = ['x = -> (y) { foo',
' bar',
'}']
new_source = autocorrect_source(cop, src)
expect(new_source).to eq(['x = -> (y) { ',
' foo',
' bar',
'}'].join("\n"))
end
it 'auto-corrects a line-break before arguments' do
new_source = autocorrect_source(cop,
['test do',
' |x| play_with(x)',
'end'])
expect(new_source).to eq(['test do |x|',
' play_with(x)',
'end'].join("\n"))
end
it 'auto-corrects a line-break before arguments with empty block' do
new_source = autocorrect_source(cop,
['test do',
' |x|',
'end'])
expect(new_source).to eq(['test do |x|',
'end'].join("\n"))
end
it 'auto-corrects a line-break within arguments' do
new_source = autocorrect_source(cop,
['test do |x,',
' y| play_with(x, y)',
'end'])
expect(new_source).to eq(['test do |x, y|',
' play_with(x, y)',
'end'].join("\n"))
end
it 'auto-corrects a line break within destructured arguments' do
new_source = autocorrect_source(cop,
['test do |(x,',
' y)| play_with(x, y)',
'end'])
expect(new_source).to eq(['test do |(x, y)|',
' play_with(x, y)',
'end'].join("\n"))
end
it "doesn't move end keyword in a way which causes infinite loop " \
'in combination with Style/BlockEndNewLine' do
new_source = autocorrect_source(cop, ['def f',
' X.map do |(a,',
' b)|',
' end',
'end'])
expect(new_source).to eq(['def f',
' X.map do |(a, b)|',
' end',
'end'].join("\n"))
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/multiline_hash_brace_layout_spec.rb 0000664 0000000 0000000 00000001730 13070542236 0030557 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::MultilineHashBraceLayout, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'EnforcedStyle' => 'symmetrical' } }
it 'ignores implicit hashes' do
inspect_source(cop, ['foo(a: 1,',
'b: 2)'])
expect(cop.offenses).to be_empty
end
it 'ignores single-line hashes' do
inspect_source(cop, '{a: 1, b: 2}')
expect(cop.offenses).to be_empty
end
it 'ignores empty hashes' do
inspect_source(cop, '{}')
expect(cop.offenses).to be_empty
end
include_examples 'multiline literal brace layout' do
let(:open) { '{' }
let(:close) { '}' }
let(:a) { 'a: 1' }
let(:b) { 'b: 2' }
let(:multi_prefix) { 'b: ' }
let(:multi) { ['[', '1', ']'] }
end
include_examples 'multiline literal brace layout trailing comma' do
let(:open) { '{' }
let(:close) { '}' }
let(:a) { 'a: 1' }
let(:b) { 'b: 2' }
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/multiline_if_modifier_spec.rb 0000664 0000000 0000000 00000005454 13070542236 0027366 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::MultilineIfModifier do
subject(:cop) { described_class.new }
shared_examples 'offense' do |modifier|
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages)
.to eq(["Favor a normal #{modifier}-statement over a modifier" \
' clause in a multiline statement.'])
end
end
shared_examples 'no offense' do
it 'does not register an offense' do
inspect_source(cop, source)
expect(cop.messages).to be_empty
end
end
shared_examples 'autocorrect' do |correct_code|
it 'auto-corrects' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq(correct_code)
end
end
context 'if guard clause' do
let(:source) do
[
'{',
' result: run',
'} if cond'
].join("\n")
end
include_examples 'offense', 'if'
include_examples 'autocorrect', "if cond\n {\n result: run\n }\nend"
context 'one liner' do
let(:source) { 'run if cond' }
include_examples 'no offense'
end
context 'multiline condition' do
let(:source) { "run if cond &&\n cond2" }
include_examples 'no offense'
end
context 'indented offense' do
let(:source) do
[
' {',
' result: run',
' } if cond'
].join("\n")
end
include_examples 'autocorrect', " if cond\n" \
" {\n" \
" result: run\n" \
" }\n" \
' end'
end
end
context 'unless guard clause' do
let(:source) do
[
'{',
' result: run',
'} unless cond'
].join("\n")
end
include_examples 'offense', 'unless'
include_examples 'autocorrect', "unless cond\n" \
" {\n" \
" result: run\n" \
" }\n" \
'end'
context 'one liner' do
let(:source) { 'run unless cond' }
include_examples 'no offense'
end
context 'multiline condition' do
let(:source) { "run unless cond &&\n cond2" }
include_examples 'no offense'
end
context 'indented offense' do
let(:source) do
[
' {',
' result: run',
' } unless cond'
].join("\n")
end
include_examples 'autocorrect', " unless cond\n" \
" {\n" \
" result: run\n" \
" }\n" \
' end'
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/multiline_if_then_spec.rb 0000664 0000000 0000000 00000007744 13070542236 0026532 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::MultilineIfThen do
subject(:cop) { described_class.new }
# if
it 'does not get confused by empty elsif branch' do
inspect_source(cop, ['if cond',
'elsif cond',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for then in multiline if' do
inspect_source(cop, ['if cond then',
'end',
"if cond then\t",
'end',
'if cond then ',
'end',
'if cond',
'then',
'end',
'if cond then # bad',
'end'])
expect(cop.offenses.map(&:line)).to eq([1, 3, 5, 8, 10])
expect(cop.highlights).to eq(['then'] * 5)
expect(cop.messages).to eq(['Do not use `then` for multi-line `if`.'] * 5)
end
it 'registers an offense for then in multiline elsif' do
inspect_source(cop, ['if cond1',
' a',
'elsif cond2 then',
' b',
'end'])
expect(cop.offenses.map(&:line)).to eq([3])
expect(cop.highlights).to eq(['then'])
expect(cop.messages).to eq(['Do not use `then` for multi-line `elsif`.'])
end
it 'accepts multiline if without then' do
inspect_source(cop, ['if cond',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts table style if/then/elsif/ends' do
inspect_source(cop,
['if @io == $stdout then str << "$stdout"',
'elsif @io == $stdin then str << "$stdin"',
'elsif @io == $stderr then str << "$stderr"',
'else str << @io.class.to_s',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not get confused by a then in a when' do
inspect_source(cop,
['if a',
' case b',
' when c then',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not get confused by a commented-out then' do
inspect_source(cop,
['if a # then',
' b',
'end',
'if c # then',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not raise an error for an implicit match if' do
expect do
inspect_source(cop,
['if //',
'end'])
end.not_to raise_error
end
# unless
it 'registers an offense for then in multiline unless' do
inspect_source(cop, ['unless cond then',
'end'])
expect(cop.messages).to eq(
['Do not use `then` for multi-line `unless`.']
)
end
it 'accepts multiline unless without then' do
inspect_source(cop, ['unless cond',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not get confused by a postfix unless' do
inspect_source(cop, 'two unless one')
expect(cop.offenses).to be_empty
end
it 'does not get confused by a nested postfix unless' do
inspect_source(cop,
['if two',
' puts 1',
'end unless two'])
expect(cop.offenses).to be_empty
end
it 'does not raise an error for an implicit match unless' do
expect do
inspect_source(cop,
['unless //',
'end'])
end.not_to raise_error
end
it 'auto-corrects the usage of "then" in multiline if' do
new_source = autocorrect_source(cop, ['if cond then',
' something',
'end'])
expect(new_source).to eq(['if cond',
' something',
'end'].join("\n"))
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/multiline_memoization_spec.rb 0000664 0000000 0000000 00000013577 13070542236 0027452 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::MultilineMemoization, :config do
subject(:cop) { described_class.new(config) }
let(:message) { described_class::MSG }
before do
inspect_source(cop, source)
end
shared_examples 'code with offense' do |code, expected|
let(:source) { code }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq([message])
end
it 'auto-corrects' do
expect(autocorrect_source(cop, code)).to eq(expected)
end
end
shared_examples 'code without offense' do |code|
let(:source) { code }
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
shared_examples 'with all enforced styles' do
context 'with a single line memoization' do
it_behaves_like 'code without offense',
'foo ||= bar'
it_behaves_like 'code without offense',
['foo ||=',
' bar'].join("\n")
end
context 'with a multiline memoization' do
context 'without a `begin` and `end` block' do
context 'when there is another block on the first line' do
it_behaves_like 'code without offense',
['foo ||= bar.each do |b|',
' b.baz',
' bb.ax',
'end'].join("\n")
end
context 'when there is another block on the following line' do
it_behaves_like 'code without offense',
['foo ||=',
' bar.each do |b|',
' b.baz',
' b.bax',
' end'].join("\n")
end
context 'when there is a conditional on the first line' do
it_behaves_like 'code without offense',
['foo ||= if bar',
' baz',
' else',
' bax',
' end'].join("\n")
end
context 'when there is a conditional on the following line' do
it_behaves_like 'code without offense',
['foo ||=',
' if bar',
' baz',
' else',
' bax',
' end'].join("\n")
end
end
end
end
context 'EnforcedStyle: keyword' do
let(:cop_config) { { 'EnforcedStyle' => 'keyword' } }
include_examples 'with all enforced styles'
context 'with a multiline memoization' do
context 'without a `begin` and `end` block' do
context 'when the expression is wrapped in parentheses' do
it_behaves_like 'code with offense',
['foo ||= (',
' bar',
' baz',
')'].join("\n"),
['foo ||= begin',
' bar',
' baz',
'end'].join("\n")
it_behaves_like 'code with offense',
['foo ||=',
' (',
' bar',
' baz',
' )'].join("\n"),
['foo ||=',
' begin',
' bar',
' baz',
' end'].join("\n")
end
end
context 'with a `begin` and `end` block on the first line' do
it_behaves_like 'code without offense',
['foo ||= begin',
' bar',
' baz',
'end'].join("\n")
end
context 'with a `begin` and `end` block on the following line' do
it_behaves_like 'code without offense',
['foo ||=',
' begin',
' bar',
' baz',
'end'].join("\n")
end
end
end
context 'EnforcedStyle: braces' do
let(:cop_config) { { 'EnforcedStyle' => 'braces' } }
include_examples 'with all enforced styles'
context 'with a multiline memoization' do
context 'without braces' do
context 'when the expression is wrapped in' \
' `begin` and `end` keywords' do
it_behaves_like 'code with offense',
['foo ||= begin',
' bar',
' baz',
'end'].join("\n"),
['foo ||= (',
' bar',
' baz',
')'].join("\n")
it_behaves_like 'code with offense',
['foo ||=',
' begin',
' bar',
' baz',
' end'].join("\n"),
['foo ||=',
' (',
' bar',
' baz',
' )'].join("\n")
end
end
context 'with parentheses on the first line' do
it_behaves_like 'code without offense',
['foo ||= (',
' bar',
' baz',
')'].join("\n")
end
context 'with parentheses block on the following line' do
it_behaves_like 'code without offense',
['foo ||=',
' (',
' bar',
' baz',
')'].join("\n")
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/multiline_method_call_brace_layout_spec.rb 0000664 0000000 0000000 00000003404 13070542236 0032107 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::MultilineMethodCallBraceLayout, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'EnforcedStyle' => 'symmetrical' } }
it 'ignores implicit calls' do
inspect_source(cop, ['foo 1,',
'2'])
expect(cop.offenses).to be_empty
end
it 'ignores single-line calls' do
inspect_source(cop, 'foo(1,2)')
expect(cop.offenses).to be_empty
end
it 'ignores calls without arguments' do
inspect_source(cop, 'puts')
expect(cop.offenses).to be_empty
end
it 'ignores calls with an empty brace' do
inspect_source(cop, 'puts()')
expect(cop.offenses).to be_empty
end
it 'ignores calls with a multiline empty brace ' do
inspect_source(cop, ['puts(',
')'])
expect(cop.offenses).to be_empty
end
include_examples 'multiline literal brace layout' do
let(:open) { 'foo(' }
let(:close) { ')' }
end
include_examples 'multiline literal brace layout trailing comma' do
let(:open) { 'foo(' }
let(:close) { ')' }
end
context 'when EnforcedStyle is new_line' do
let(:cop_config) { { 'EnforcedStyle' => 'new_line' } }
it 'still ignores single-line calls' do
inspect_source(cop, 'puts("Hello world!")')
expect(cop.offenses).to be_empty
end
it 'ignores single-line calls with multi-line receiver' do
inspect_source(cop, ['[',
'].join(" ")'])
expect(cop.offenses).to be_empty
end
it 'ignores single-line calls with multi-line receiver with leading dot' do
inspect_source(cop, ['[',
']',
'.join(" ")'])
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/multiline_method_call_indentation_spec.rb 0000664 0000000 0000000 00000077074 13070542236 0031770 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::MultilineMethodCallIndentation do
subject(:cop) { described_class.new(config) }
let(:config) do
merged = RuboCop::ConfigLoader
.default_configuration['Style/MultilineMethodCallIndentation']
.merge(cop_config)
.merge('IndentationWidth' => cop_indent)
RuboCop::Config
.new('Style/MultilineMethodCallIndentation' => merged,
'Style/IndentationWidth' => { 'Width' => indentation_width })
end
let(:indentation_width) { 2 }
let(:cop_indent) { nil } # use indentation width from Style/IndentationWidth
shared_examples 'common' do
it 'accepts indented methods in LHS of []= assignment' do
inspect_source(cop,
['a',
' .b[c] = 0'])
expect(cop.offenses).to be_empty
end
it 'accepts indented methods inside and outside a block' do
inspect_source(cop,
['a = b.map do |c|',
' c',
' .b',
' .d do',
' x',
' .y',
' end',
'end'])
expect(cop.messages).to be_empty
end
it 'accepts indentation relative to first receiver' do
inspect_source(cop,
['node',
' .children.map { |n| string_source(n) }.compact',
' .any? { |s| preferred.any? { |d| s.include?(d) } }'])
expect(cop.offenses).to be_empty
end
it 'accepts indented methods in ordinary statement' do
inspect_source(cop,
['a.',
' b'])
expect(cop.messages).to be_empty
end
it 'accepts no extra indentation of third line' do
inspect_source(cop,
[' a.',
' b.',
' c'])
expect(cop.offenses).to be_empty
end
it 'accepts indented methods in for body' do
inspect_source(cop,
['for x in a',
' something.',
' something_else',
'end'])
expect(cop.highlights).to be_empty
end
it 'accepts alignment inside a grouped expression' do
inspect_source(cop,
['(a.',
' b)'])
expect(cop.messages).to be_empty
end
it 'accepts an expression where the first method spans multiple lines' do
inspect_source(cop,
['subject.each do |item|',
' result = resolve(locale) and return result',
'end.a'])
expect(cop.messages).to be_empty
end
it 'accepts any indentation of parameters to #[]' do
inspect_source(cop,
['payment = Models::IncomingPayments[',
" id: input['incoming-payment-id'],",
' user_id: @user[:id]]'])
expect(cop.messages).to be_empty
end
it "doesn't fail on unary operators" do
inspect_source(cop,
['def foo',
' !0',
' .nil?',
'end'])
expect(cop.offenses.size).to eq(1)
end
end
shared_examples 'common for aligned and indented' do
it 'accepts even indentation of consecutive lines in typical RSpec code' do
inspect_source(cop,
['expect { Foo.new }.',
' to change { Bar.count }.',
' from(1).to(2)'])
expect(cop.messages).to be_empty
end
it 'registers an offense for no indentation of second line' do
inspect_source(cop,
['a.',
'b'])
expect(cop.messages)
.to eq(['Use 2 (not 0) spaces for indenting an expression spanning ' \
'multiple lines.'])
expect(cop.highlights).to eq(['b'])
end
it 'registers an offense for 3 spaces indentation of second line' do
inspect_source(cop,
['a.',
' b',
'c.',
' d'])
expect(cop.messages)
.to eq(['Use 2 (not 3) spaces for indenting an expression spanning ' \
'multiple lines.'] * 2)
expect(cop.highlights).to eq(%w[b d])
end
it 'registers an offense for extra indentation of third line' do
inspect_source(cop,
[' a.',
' b.',
' c'])
expect(cop.messages)
.to eq(['Use 2 (not 4) spaces for indenting an expression spanning ' \
'multiple lines.'])
expect(cop.highlights).to eq(['c'])
end
it 'registers an offense for the emacs ruby-mode 1.1 indentation of an ' \
'expression in an array' do
inspect_source(cop,
[' [',
' a.',
' b',
' ]'])
expect(cop.messages)
.to eq(['Use 2 (not 0) spaces for indenting an expression spanning ' \
'multiple lines.'])
expect(cop.highlights).to eq(['b'])
end
it 'registers an offense for extra indentation of 3rd line in typical ' \
'RSpec code' do
inspect_source(cop,
['expect { Foo.new }.',
' to change { Bar.count }.',
' from(1).to(2)'])
expect(cop.messages).to eq(['Use 2 (not 6) spaces for indenting an ' \
'expression spanning multiple lines.'])
expect(cop.highlights).to eq(['from'])
end
it 'registers an offense for proc call without a selector' do
inspect_source(cop,
['a',
' .(args)'])
expect(cop.messages).to eq(['Use 2 (not 1) spaces for indenting an ' \
'expression spanning multiple lines.'])
expect(cop.highlights).to eq(['.('])
end
it 'registers an offense for one space indentation of second line' do
inspect_source(cop,
['a',
' .b'])
expect(cop.messages).to eq(['Use 2 (not 1) spaces for indenting an ' \
'expression spanning multiple lines.'])
expect(cop.highlights).to eq(['.b'])
end
end
context 'when EnforcedStyle is aligned' do
let(:cop_config) { { 'EnforcedStyle' => 'aligned' } }
include_examples 'common'
include_examples 'common for aligned and indented'
# We call it semantic alignment when a dot is aligned with the first dot in
# a chain of calls, and that first dot does not begin its line.
context 'for semantic alignment' do
it 'accepts method being aligned with method' do
inspect_source(cop,
['User.all.first',
' .age.to_s'])
expect(cop.offenses).to be_empty
end
it 'accepts method being aligned with method in assignment' do
inspect_source(cop,
['age = User.all.first',
' .age.to_s'])
expect(cop.offenses).to be_empty
end
it 'accepts aligned method even when an aref is in the chain' do
inspect_source(cop, ["foo = '123'.a",
' .b[1]',
' .c'])
expect(cop.offenses).to be_empty
end
it 'accepts aligned method even when an aref is first in the chain' do
inspect_source(cop, ["foo = '123'[1].a",
' .b',
' .c'])
expect(cop.offenses).to be_empty
end
it "doesn't fail on a chain of aref calls" do
inspect_source(cop, 'a[1][2][3]')
expect(cop.offenses).to be_empty
end
it 'accepts aligned method with blocks in operation assignment' do
inspect_source(cop,
['@comment_lines ||=',
' src.comments',
' .select { |c| begins_its_line?(c) }',
' .map { |c| c.loc.line }'])
expect(cop.offenses).to be_empty
end
it 'accepts 3 aligned methods' do
inspect_source(cop,
["a_class.new(severity, location, 'message', 'CopName')",
' .severity',
' .level'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for unaligned methods' do
inspect_source(cop,
['User.a',
' .b',
' .c'])
expect(cop.messages).to eq(['Align `.b` with `.a` on line 1.',
'Align `.c` with `.a` on line 1.'])
expect(cop.highlights).to eq(['.b', '.c'])
end
it 'registers an offense for unaligned method in block body' do
inspect_source(cop,
['a do',
' b.c',
' .d',
'end'])
expect(cop.messages).to eq(['Align `.d` with `.c` on line 2.'])
expect(cop.highlights).to eq(['.d'])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, ['User.all.first',
' .age.to_s'])
expect(new_source).to eq(['User.all.first',
' .age.to_s'].join("\n"))
end
end
it 'accepts correctly aligned methods in operands' do
inspect_source(cop, ['1 + a',
' .b',
' .c + d.',
' e'])
expect(cop.offenses).to be_empty
end
it 'accepts correctly aligned methods in assignment' do
inspect_source(cop, ['def investigate(processed_source)',
' @modifier = processed_source',
' .tokens',
' .select { |t| t.type == :k }',
' .map(&:pos)',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts aligned methods in if + assignment' do
inspect_source(cop,
['KeyMap = Hash.new do |map, key|',
' value = if key.respond_to?(:to_str)',
' key',
' else',
" key.to_s.split('_').",
' each { |w| w.capitalize! }.',
" join('-')",
' end',
' keymap_mutex.synchronize { map[key] = value }',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts indented method when there is nothing to align with' do
inspect_source(cop,
["expect { custom_formatter_class('NonExistentClass') }",
' .to raise_error(NameError)'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for one space indentation of third line' do
inspect_source(cop,
['a',
' .b',
' .c'])
expect(cop.messages)
.to eq(['Use 2 (not 1) spaces for indenting an expression spanning ' \
'multiple lines.'])
expect(cop.highlights).to eq(['.c'])
end
it 'accepts indented and aligned methods in binary operation' do
inspect_source(cop,
['a.',
' b + c', # b is indented relative to a
' .d']) # .d is aligned with c
expect(cop.offenses).to be_empty
end
it 'accepts aligned methods in if condition' do
inspect_source(cop,
['if a.',
' b',
' something',
'end'])
expect(cop.messages).to be_empty
end
it 'accepts aligned methods in a begin..end block' do
inspect_source(cop,
['@dependencies ||= begin',
' DEFAULT_DEPENDENCIES',
' .reject { |e| e }',
' .map { |e| e }',
'end'])
expect(cop.messages).to be_empty
end
it 'registers an offense for misaligned methods in if condition' do
inspect_source(cop,
['if a.',
' b',
' something',
'end'])
expect(cop.messages).to eq(['Align `b` with `a.` on line 1.'])
expect(cop.highlights).to eq(['b'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'falls back to indentation in complicated cases' do
inspect_source(cop,
# There are two method call chains here. The last one is
# an argument to the first, and they both start on the
# same line.
['expect(RuboCop::ConfigLoader).to receive(:file).once',
" .with('dir')"])
expect(cop.messages)
.to eq(['Use 2 (not 4) spaces for indenting an expression spanning ' \
'multiple lines.'])
expect(cop.highlights).to eq(['.with'])
end
it 'does not check binary operations when string wrapped with backslash' do
inspect_source(cop,
["flash[:error] = 'Here is a string ' \\",
" 'That spans' <<",
" 'multiple lines'"])
expect(cop.offenses).to be_empty
end
it 'does not check binary operations when string wrapped with +' do
inspect_source(cop,
["flash[:error] = 'Here is a string ' +",
" 'That spans' <<",
" 'multiple lines'"])
expect(cop.offenses).to be_empty
end
it 'registers an offense for misaligned method in []= call' do
inspect_source(cop,
['flash[:error] = here_is_a_string.',
' that_spans.',
' multiple_lines'])
expect(cop.messages)
.to eq(['Align `multiple_lines` with `here_is_a_string.` on line 1.'])
expect(cop.highlights).to eq(['multiple_lines'])
end
it 'registers an offense for misaligned methods in unless condition' do
inspect_source(cop,
['unless a',
'.b',
' something',
'end'])
expect(cop.messages).to eq(['Align `.b` with `a` on line 1.'])
expect(cop.highlights).to eq(['.b'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'registers an offense for misaligned methods in while condition' do
inspect_source(cop,
['while a.',
' b',
' something',
'end'])
expect(cop.messages).to eq(['Align `b` with `a.` on line 1.'])
expect(cop.highlights).to eq(['b'])
end
it 'registers an offense for misaligned methods in until condition' do
inspect_source(cop,
['until a.',
' b',
' something',
'end'])
expect(cop.messages).to eq(['Align `b` with `a.` on line 1.'])
expect(cop.highlights).to eq(['b'])
end
it 'accepts aligned method in return' do
inspect_source(cop,
['def a',
' return b.',
' c',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts aligned method in assignment + block + assignment' do
inspect_source(cop,
['a = b do',
' c.d = e.',
' f',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts aligned methods in assignment' do
inspect_source(cop,
['formatted_int = int_part',
' .to_s',
' .reverse',
" .gsub(/...(?=.)/, '\&_')"])
expect(cop.messages).to be_empty
end
it 'registers an offense for misaligned methods in local variable ' \
'assignment' do
inspect_source(cop, ['a = b.c.',
' d'])
expect(cop.messages).to eq(['Align `d` with `b.c.` on line 1.'])
expect(cop.highlights).to eq(['d'])
end
it 'accepts aligned methods in constant assignment' do
inspect_source(cop, ['A = b',
' .c'])
expect(cop.offenses).to be_empty
end
it 'accepts aligned methods in operator assignment' do
inspect_source(cop, ['a +=',
' b',
' .c'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for unaligned methods in assignment' do
inspect_source(cop,
['bar = Foo',
' .a',
' .b(c)'])
expect(cop.messages).to eq(['Align `.a` with `Foo` on line 1.'])
expect(cop.highlights).to eq(['.a'])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, ['until a.',
' b',
' something',
'end'])
expect(new_source).to eq(['until a.',
' b',
' something',
'end'].join("\n"))
end
end
shared_examples 'both indented* styles' do
# We call it semantic alignment when a dot is aligned with the first dot in
# a chain of calls, and that first dot does not begin its line. But for the
# indented style, it doesn't come into play.
context 'for possible semantic alignment' do
it 'accepts indented methods' do
inspect_source(cop,
['User.a',
' .c',
' .b'])
expect(cop.messages).to be_empty
expect(cop.highlights).to be_empty
expect(cop.offenses).to be_empty
end
end
end
context 'when EnforcedStyle is indented_relative_to_receiver' do
let(:cop_config) { { 'EnforcedStyle' => 'indented_relative_to_receiver' } }
include_examples 'common'
include_examples 'both indented* styles'
it 'accepts correctly indented methods in operation' do
inspect_source(cop, [' 1 + a',
' .b',
' .c'])
expect(cop.highlights).to be_empty
expect(cop.offenses).to be_empty
end
it 'accepts indentation of consecutive lines in typical RSpec code' do
inspect_source(cop,
['expect { Foo.new }.',
' to change { Bar.count }.',
' from(1).to(2)'])
expect(cop.messages).to be_empty
inspect_source(cop,
['expect { Foo.new }.to change { Bar.count }',
' .from(1).to(2)'])
expect(cop.messages).to be_empty
end
it 'registers an offense for no indentation of second line' do
inspect_source(cop,
['a.',
'b'])
expect(cop.messages)
.to eq(['Indent `b` 2 spaces more than `a` on line 1.'])
expect(cop.highlights).to eq(['b'])
end
it 'registers an offense for extra indentation of 3rd line in typical ' \
'RSpec code' do
inspect_source(cop,
['expect { Foo.new }.',
' to change { Bar.count }.',
' from(1).to(2)'])
expect(cop.messages).to eq(['Indent `from` 2 spaces more than `change ' \
'{ Bar.count }` on line 2.'])
expect(cop.highlights).to eq(['from'])
end
it 'registers an offense for proc call without a selector' do
inspect_source(cop,
['a',
' .(args)'])
expect(cop.messages).to eq(['Indent `.(` 2 spaces more than `a` on ' \
'line 1.'])
expect(cop.highlights).to eq(['.('])
end
it 'registers an offense for one space indentation of second line' do
inspect_source(cop,
['a',
' .b'])
expect(cop.messages).to eq(['Indent `.b` 2 spaces more than `a` on ' \
'line 1.'])
expect(cop.highlights).to eq(['.b'])
end
it 'registers an offense for 3 spaces indentation of second line' do
inspect_source(cop,
['a.',
' b',
'c.',
' d'])
expect(cop.messages)
.to eq(['Indent `b` 2 spaces more than `a` on line 1.',
'Indent `d` 2 spaces more than `c` on line 3.'])
expect(cop.highlights).to eq(%w[b d])
end
it 'registers an offense for extra indentation of third line' do
inspect_source(cop,
[' a.',
' b.',
' c'])
expect(cop.messages)
.to eq(['Indent `c` 2 spaces more than `a` on line 1.'])
expect(cop.highlights).to eq(['c'])
end
it 'registers an offense for the emacs ruby-mode 1.1 indentation of an ' \
'expression in an array' do
inspect_source(cop,
[' [',
' a.',
' b',
' ]'])
expect(cop.messages)
.to eq(['Indent `b` 2 spaces more than `a` on line 2.'])
expect(cop.highlights).to eq(['b'])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, ['until a.',
' b',
' something',
'end'])
expect(new_source).to eq(['until a.',
' b',
' something',
'end'].join("\n"))
end
end
context 'when EnforcedStyle is indented' do
let(:cop_config) { { 'EnforcedStyle' => 'indented' } }
include_examples 'common'
include_examples 'common for aligned and indented'
include_examples 'both indented* styles'
it 'accepts correctly indented methods in operation' do
inspect_source(cop, [' 1 + a',
' .b',
' .c'])
expect(cop.offenses).to be_empty
expect(cop.highlights).to be_empty
end
it 'registers an offense for one space indentation of third line' do
inspect_source(cop,
['a',
' .b',
' .c'])
expect(cop.messages).to eq(['Use 2 (not 1) spaces for indenting an ' \
'expression spanning multiple lines.'])
expect(cop.highlights).to eq(['.c'])
end
it 'accepts indented methods in if condition' do
inspect_source(cop,
['if a.',
' b',
' something',
'end'])
expect(cop.messages).to be_empty
end
it 'registers an offense for aligned methods in if condition' do
inspect_source(cop,
['if a.',
' b',
' something',
'end'])
expect(cop.messages).to eq(['Use 4 (not 3) spaces for indenting a ' \
'condition in an `if` statement spanning ' \
'multiple lines.'])
expect(cop.highlights).to eq(['b'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'accepts normal indentation of method parameters' do
inspect_source(cop,
['Parser::Source::Range.new(expr.source_buffer,',
' begin_pos,',
' begin_pos + line.length)'])
expect(cop.messages).to be_empty
end
it 'accepts any indentation of method parameters' do
inspect_source(cop,
['a(b.',
' c',
'.d)'])
expect(cop.messages).to be_empty
end
it 'accepts normal indentation inside grouped expression' do
inspect_source(cop,
['arg_array.size == a.size && (',
' arg_array == a ||',
' arg_array.map(&:children) == a.map(&:children)',
')'])
expect(cop.messages).to be_empty
end
[
%w[an if],
%w[an unless],
%w[a while],
%w[an until]
].each do |article, keyword|
it "accepts double indentation of #{keyword} condition" do
inspect_source(cop,
["#{keyword} receiver.",
' nil? &&',
' !args.empty?',
'end'])
expect(cop.messages).to be_empty
end
it "registers an offense for a 2 space indentation of #{keyword} " \
'condition' do
inspect_source(cop,
["#{keyword} receiver",
' .nil? &&',
' !args.empty?',
'end'])
expect(cop.highlights).to eq(['.nil?'])
expect(cop.messages).to eq(['Use 4 (not 2) spaces for indenting a ' \
"condition in #{article} `#{keyword}` " \
'statement spanning multiple lines.'])
end
it "accepts indented methods in #{keyword} body" do
inspect_source(cop,
["#{keyword} a",
' something.',
' something_else',
'end'])
expect(cop.highlights).to be_empty
end
end
%w[unless if].each do |keyword|
it "accepts special indentation of return #{keyword} condition" do
inspect_source(cop,
["return #{keyword} receiver.nil? &&",
' !args.empty? &&',
' BLACKLIST.include?(method_name)'])
expect(cop.messages).to be_empty
end
end
it 'registers an offense for wrong indentation of for expression' do
inspect_source(cop,
['for n in a.',
' b',
'end'])
expect(cop.messages).to eq(['Use 4 (not 2) spaces for indenting a ' \
'collection in a `for` statement spanning ' \
'multiple lines.'])
expect(cop.highlights).to eq(['b'])
end
it 'accepts special indentation of for expression' do
inspect_source(cop,
['for n in a.',
' b',
'end'])
expect(cop.messages).to be_empty
end
it 'accepts indentation of assignment' do
inspect_source(cop,
['formatted_int = int_part',
' .abs',
' .to_s',
' .reverse',
" .gsub(/...(?=.)/, '\&_')",
' .reverse'])
expect(cop.messages).to be_empty
end
it 'registers an offense for correct + unrecognized style' do
inspect_source(cop,
['a.',
' b',
'c.',
' d'])
expect(cop.messages).to eq(['Use 2 (not 4) spaces for indenting an ' \
'expression spanning multiple lines.'])
expect(cop.highlights).to eq(%w[d])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'registers an offense for aligned operators in assignment' do
inspect_source(cop,
['formatted_int = int_part',
' .abs',
' .reverse'])
expect(cop.messages).to eq(['Use 2 (not 16) spaces for indenting an ' \
'expression in an assignment spanning ' \
'multiple lines.'] * 2)
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, ['until a.',
' b',
' something',
'end'])
expect(new_source).to eq(['until a.',
' b',
' something',
'end'].join("\n"))
end
context 'when indentation width is overridden for this cop' do
let(:cop_indent) { 7 }
it 'accepts indented methods' do
inspect_source(cop,
['User.a',
' .c',
' .b'])
expect(cop.offenses).to be_empty
end
it 'accepts correctly indented methods in operation' do
inspect_source(cop, [' 1 + a',
' .b',
' .c'])
expect(cop.offenses).to be_empty
expect(cop.highlights).to be_empty
end
it 'accepts indented methods in if condition' do
inspect_source(cop,
['if a.',
' b',
' something',
'end'])
expect(cop.messages).to be_empty
end
it 'accepts indentation of assignment' do
inspect_source(cop,
['formatted_int = int_part',
' .abs',
' .to_s',
' .reverse'])
expect(cop.messages).to be_empty
end
[
%w[an if],
%w[an unless],
%w[a while],
%w[an until]
].each do |article, keyword|
it "accepts indentation of #{keyword} condition which is offset " \
'by a single normal indentation step' do
# normal code indentation is 2 spaces, and we have configured
# multiline method indentation to 7 spaces
# so in this case, 9 spaces are required
inspect_source(cop,
["#{keyword} receiver.",
' nil? &&',
' !args.empty?',
'end'])
expect(cop.messages).to be_empty
end
it "registers an offense for a 4 space indentation of #{keyword} " \
'condition' do
inspect_source(cop,
["#{keyword} receiver",
' .nil? &&',
' !args.empty?',
'end'])
expect(cop.highlights).to eq(['.nil?'])
expect(cop.messages).to eq(['Use 9 (not 4) spaces for indenting a ' \
"condition in #{article} `#{keyword}` " \
'statement spanning multiple lines.'])
end
it "accepts indented methods in #{keyword} body" do
inspect_source(cop,
["#{keyword} a",
' something.',
' something_else',
'end'])
expect(cop.highlights).to be_empty
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/multiline_method_definition_brace_layout_spec.rb 0000664 0000000 0000000 00000001621 13070542236 0033323 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::MultilineMethodDefinitionBraceLayout, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'EnforcedStyle' => 'symmetrical' } }
it 'ignores implicit defs' do
inspect_source(cop, ['def foo a: 1,',
'b: 2',
'end'])
expect(cop.offenses).to be_empty
end
it 'ignores single-line defs' do
inspect_source(cop, ['def foo(a,b)',
'end'])
expect(cop.offenses).to be_empty
end
it 'ignores defs without params' do
inspect_source(cop, ['def foo',
'end'])
expect(cop.offenses).to be_empty
end
include_examples 'multiline literal brace layout' do
let(:prefix) { 'def foo' }
let(:suffix) { 'end' }
let(:open) { '(' }
let(:close) { ')' }
let(:multi_prefix) { 'b: ' }
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/multiline_operation_indentation_spec.rb 0000664 0000000 0000000 00000054070 13070542236 0031504 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::MultilineOperationIndentation do
subject(:cop) { described_class.new(config) }
let(:config) do
merged = RuboCop::ConfigLoader
.default_configuration['Style/MultilineOperationIndentation']
.merge(cop_config)
.merge('IndentationWidth' => cop_indent)
RuboCop::Config
.new('Style/MultilineOperationIndentation' => merged,
'Style/IndentationWidth' => { 'Width' => indentation_width })
end
let(:indentation_width) { 2 }
let(:cop_indent) { nil } # use indentation width from Style/IndentationWidth
shared_examples 'common' do
it 'accepts indented operands in ordinary statement' do
inspect_source(cop,
['a +',
' b'])
expect(cop.messages).to be_empty
end
it 'accepts indented operands inside and outside a block' do
inspect_source(cop,
['a = b.map do |c|',
' c +',
' b +',
' d do',
' x +',
' y',
' end',
'end'])
expect(cop.messages).to be_empty
end
it 'registers an offense for no indentation of second line' do
inspect_source(cop,
['a +',
'b'])
expect(cop.messages).to eq(['Use 2 (not 0) spaces for indenting an ' \
'expression spanning multiple lines.'])
expect(cop.highlights).to eq(['b'])
end
it 'registers an offense for one space indentation of second line' do
inspect_source(cop,
['a +',
' b'])
expect(cop.messages).to eq(['Use 2 (not 1) spaces for indenting an ' \
'expression spanning multiple lines.'])
expect(cop.highlights).to eq(['b'])
end
it 'does not check method calls' do
inspect_source(cop,
['a',
' .(args)',
'',
'Foo',
'.a',
' .b',
'',
'Foo',
'.a',
' .b(c)',
'',
'expect { Foo.new }.',
' to change { Bar.count }.',
' from(1).to(2)'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for three spaces indentation of second line' do
inspect_source(cop,
['a ||',
' b',
'c and',
' d'])
expect(cop.messages).to eq(['Use 2 (not 3) spaces for indenting an ' \
'expression spanning multiple lines.'] * 2)
expect(cop.highlights).to eq(%w[b d])
end
it 'registers an offense for extra indentation of third line' do
inspect_source(cop,
[' a ||',
' b ||',
' c'])
expect(cop.messages).to eq(['Use 2 (not 4) spaces for indenting an ' \
'expression spanning multiple lines.'])
expect(cop.highlights).to eq(['c'])
end
it 'registers an offense for the emacs ruby-mode 1.1 indentation of an ' \
'expression in an array' do
inspect_source(cop,
[' [',
' a +',
' b',
' ]'])
expect(cop.messages).to eq(['Use 2 (not 0) spaces for indenting an ' \
'expression spanning multiple lines.'])
expect(cop.highlights).to eq(['b'])
end
it 'accepts indented operands in an array' do
inspect_source(cop, [' dm[i][j] = [',
' dm[i-1][j-1] +',
' (this[j-1] == that[i-1] ? 0 : sub),',
' dm[i][j-1] + ins,',
' dm[i-1][j] + del',
' ].min'])
expect(cop.offenses).to be_empty
end
it 'accepts two spaces indentation in assignment of local variable' do
inspect_source(cop,
['a =',
" 'foo' +",
" 'bar'"])
expect(cop.messages).to be_empty
end
it 'accepts two spaces indentation in assignment of array element' do
inspect_source(cop,
["a['test'] =",
" 'foo' +",
" 'bar'"])
expect(cop.messages).to be_empty
end
it 'accepts two spaces indentation of second line' do
inspect_source(cop,
[' a ||',
' b'])
expect(cop.messages).to be_empty
end
it 'accepts no extra indentation of third line' do
inspect_source(cop,
[' a &&',
' b &&',
' c'])
expect(cop.messages).to be_empty
end
it 'accepts indented operands in for body' do
inspect_source(cop,
['for x in a',
' something &&',
' something_else',
'end'])
expect(cop.highlights).to be_empty
end
it 'accepts alignment inside a grouped expression' do
inspect_source(cop,
['(a +',
' b)'])
expect(cop.messages).to be_empty
end
it 'accepts an expression where the first operand spans multiple lines' do
inspect_source(cop,
['subject.each do |item|',
' result = resolve(locale) and return result',
'end and nil'])
expect(cop.messages).to be_empty
end
it 'accepts any indentation of parameters to #[]' do
inspect_source(cop,
['payment = Models::IncomingPayments[',
" id: input['incoming-payment-id'],",
' user_id: @user[:id]]'])
expect(cop.messages).to be_empty
end
it 'registers an offense for an unindented multiline operation that is ' \
'the left operand in another operation' do
inspect_source(cop, ['a +',
'b < 3'])
expect(cop.messages).to eq(['Use 2 (not 0) spaces for indenting an ' \
'expression spanning multiple lines.'])
expect(cop.highlights).to eq(['b'])
end
end
context 'when EnforcedStyle is aligned' do
let(:cop_config) { { 'EnforcedStyle' => 'aligned' } }
include_examples 'common'
it 'accepts aligned operands in if condition' do
inspect_source(cop,
['if a +',
' b',
' something',
'end'])
expect(cop.messages).to be_empty
end
it 'registers an offense for indented operands in if condition' do
inspect_source(cop,
['if a +',
' b',
' something',
'end'])
expect(cop.messages).to eq(['Align the operands of a condition in an ' \
'`if` statement spanning multiple lines.'])
expect(cop.highlights).to eq(['b'])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'indented')
end
it 'accepts indented code on LHS of equality operator' do
inspect_source(cop, ['def config_to_allow_offenses',
' a +',
' b == c ',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts indented operands inside block + assignment' do
inspect_source(cop, ['a = b.map do |c|',
' c +',
' d',
'end',
'',
'requires_interpolation = node.children.any? do |s|',
' s.type == :dstr ||',
' s.loc.expression.source =~ REGEXP',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for indented second part of string' do
inspect_source(cop,
['it "should convert " +',
' "a to " +',
' "b" do',
'end'])
expect(cop.messages).to eq(['Align the operands of an expression ' \
'spanning multiple lines.'] * 2)
expect(cop.highlights).to eq(['"a to "', '"b"'])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'indented')
end
it 'registers an offense for indented operand in second argument' do
inspect_source(cop,
['puts a, 1 +',
' 2'])
expect(cop.messages)
.to eq(['Align the operands of an expression spanning multiple lines.'])
expect(cop.highlights).to eq(['2'])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'indented')
end
it 'registers an offense for misaligned string operand when the first ' \
'operand has backslash continuation' do
inspect_source(cop,
['def f',
" flash[:error] = 'Here is a string ' \\",
" 'That spans' <<",
" 'multiple lines'",
'end'])
expect(cop.messages).to eq(['Align the operands of an expression in an ' \
'assignment spanning multiple lines.'])
expect(cop.highlights).to eq(["'multiple lines'"])
end
it 'registers an offense for misaligned string operand when plus is used' do
inspect_source(cop,
["Error = 'Here is a string ' +",
" 'That spans' <<",
" 'multiple lines'"])
expect(cop.messages).to eq(['Align the operands of an expression in an ' \
'assignment spanning multiple lines.'])
expect(cop.highlights).to eq(["'multiple lines'"])
end
it 'registers an offense for misaligned operands in unless condition' do
inspect_source(cop,
['unless a +',
' b',
' something',
'end'])
expect(cop.messages).to eq(['Align the operands of a condition in an ' \
'`unless` statement spanning multiple ' \
'lines.'])
expect(cop.highlights).to eq(['b'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
[
%w[an if],
%w[an unless],
%w[a while],
%w[an until]
].each do |article, keyword|
it "registers an offense for misaligned operands in #{keyword} " \
'condition' do
inspect_source(cop,
["#{keyword} a or",
' b',
' something',
'end'])
expect(cop.messages).to eq(['Align the operands of a condition in ' \
"#{article} `#{keyword}` statement " \
'spanning multiple lines.'])
expect(cop.highlights).to eq(['b'])
expect(cop.config_to_allow_offenses)
.to eq('EnforcedStyle' => 'indented')
end
end
it 'accepts aligned operands in assignment' do
inspect_source(cop,
['a = b +',
' c +',
' d'])
expect(cop.offenses).to be_empty
end
it 'accepts aligned or:ed operands in assignment' do
inspect_source(cop,
["tmp_dir = ENV['TMPDIR'] || ENV['TMP'] || ENV['TEMP'] ||",
" Etc.systmpdir || '/tmp'"])
expect(cop.messages).to be_empty
end
it 'registers an offense for unaligned operands in op-assignment' do
inspect_source(cop,
['bar *= Foo +',
' a +',
' b(c)'])
expect(cop.messages).to eq(['Align the operands of an expression in an ' \
'assignment spanning multiple lines.'])
expect(cop.highlights).to eq(['a'])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, ['until a +',
' b',
' something',
'end'])
expect(new_source).to eq(['until a +',
' b',
' something',
'end'].join("\n"))
end
end
context 'when EnforcedStyle is indented' do
let(:cop_config) { { 'EnforcedStyle' => 'indented' } }
include_examples 'common'
it 'accepts indented operands in if condition' do
inspect_source(cop,
['if a +',
' b',
' something',
'end'])
expect(cop.messages).to be_empty
end
it 'registers an offense for aligned operands in if condition' do
inspect_source(cop,
['if a +',
' b',
' something',
'end'])
expect(cop.messages).to eq(['Use 4 (not 3) spaces for indenting a ' \
'condition in an `if` statement spanning ' \
'multiple lines.'])
expect(cop.highlights).to eq(['b'])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'aligned')
end
it 'accepts the indentation of a broken string' do
inspect_source(cop,
["MSG = 'Use 2 (not %d) spaces for indenting a ' \\",
" 'broken line.'"])
expect(cop.messages).to be_empty
end
it 'accepts normal indentation of method parameters' do
inspect_source(cop,
['Parser::Source::Range.new(expr.source_buffer,',
' begin_pos,',
' begin_pos + line.length)'])
expect(cop.messages).to be_empty
end
it 'accepts any indentation of method parameters' do
inspect_source(cop,
['a(b +',
' c +',
'd)'])
expect(cop.messages).to be_empty
end
it 'accepts normal indentation inside grouped expression' do
inspect_source(cop,
['arg_array.size == a.size && (',
' arg_array == a ||',
' arg_array.map(&:children) == a.map(&:children)',
')'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for aligned code on LHS of equality operator' do
inspect_source(cop, ['def config_to_allow_offenses',
' a +',
' b == c ',
'end'])
expect(cop.messages).to eq(['Use 2 (not 0) spaces for indenting an ' \
'expression spanning multiple lines.'])
end
[
%w[an if],
%w[an unless],
%w[a while],
%w[an until]
].each do |article, keyword|
it "accepts double indentation of #{keyword} condition" do
inspect_source(cop,
["#{keyword} receiver.nil? &&",
' !args.empty? &&',
' BLACKLIST.include?(method_name)',
'end',
"#{keyword} receiver.",
' nil?',
'end'])
expect(cop.messages).to be_empty
end
it "registers an offense for a 2 space indentation of #{keyword} " \
'condition' do
inspect_source(cop,
["#{keyword} receiver.nil? &&",
' !args.empty? &&',
' BLACKLIST.include?(method_name)',
'end'])
expect(cop.highlights).to eq(['!args.empty?',
'BLACKLIST.include?(method_name)'])
expect(cop.messages).to eq(['Use 4 (not 2) spaces for indenting a ' \
"condition in #{article} `#{keyword}` " \
'statement spanning multiple lines.'] * 2)
end
it "accepts indented operands in #{keyword} body" do
inspect_source(cop,
["#{keyword} a",
' something &&',
' something_else',
'end'])
expect(cop.highlights).to be_empty
end
end
%w[unless if].each do |keyword|
it "accepts special indentation of return #{keyword} condition" do
inspect_source(cop,
["return #{keyword} receiver.nil? &&",
' !args.empty? &&',
' BLACKLIST.include?(method_name)'])
expect(cop.messages).to be_empty
end
end
it 'registers an offense for wrong indentation of for expression' do
inspect_source(cop,
['for n in a +',
' b',
'end'])
expect(cop.messages).to eq(['Use 4 (not 2) spaces for indenting a ' \
'collection in a `for` statement spanning ' \
'multiple lines.'])
expect(cop.highlights).to eq(['b'])
end
it 'accepts special indentation of for expression' do
inspect_source(cop,
['for n in a +',
' b',
'end'])
expect(cop.messages).to be_empty
end
it 'accepts indentation of assignment' do
inspect_source(cop,
['a = b +',
' c +',
' d'])
expect(cop.messages).to be_empty
end
it 'registers an offense for correct + unrecognized style' do
inspect_source(cop,
['a ||',
' b',
'c and',
' d'])
expect(cop.messages).to eq(['Use 2 (not 4) spaces for indenting an ' \
'expression spanning multiple lines.'])
expect(cop.highlights).to eq(%w[d])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'registers an offense for aligned operators in assignment' do
inspect_source(cop,
['a = b +',
' c +',
' d'])
expect(cop.messages).to eq(['Use 2 (not 4) spaces for indenting an ' \
'expression in an assignment spanning ' \
'multiple lines.'] * 2)
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, ['until a +',
' b',
' something',
'end'])
expect(new_source).to eq(['until a +',
' b',
' something',
'end'].join("\n"))
end
context 'when indentation width is overridden for this cop' do
let(:cop_indent) { 6 }
it 'accepts indented operands in if condition' do
inspect_source(cop,
['if a +',
' b',
' something',
'end'])
expect(cop.messages).to be_empty
end
[
%w[an if],
%w[an unless],
%w[a while],
%w[an until]
].each do |article, keyword|
it "accepts indentation of #{keyword} condition which is offset " \
'by a single normal indentation step' do
# normal code indentation is 2 spaces, and we have configured
# multiline method indentation to 6 spaces
# so in this case, 8 spaces are required
inspect_source(cop,
["#{keyword} receiver.nil? &&",
' !args.empty? &&',
' BLACKLIST.include?(method_name)',
'end',
"#{keyword} receiver.",
' nil?',
'end'])
expect(cop.messages).to be_empty
end
it "registers an offense for a 4 space indentation of #{keyword} " \
'condition' do
inspect_source(cop,
["#{keyword} receiver.nil? &&",
' !args.empty? &&',
' BLACKLIST.include?(method_name)',
'end'])
expect(cop.highlights).to eq(['!args.empty?',
'BLACKLIST.include?(method_name)'])
expect(cop.messages).to eq(['Use 8 (not 4) spaces for indenting a ' \
"condition in #{article} `#{keyword}` " \
'statement spanning multiple lines.'] * 2)
end
it "accepts indented operands in #{keyword} body" do
inspect_source(cop,
["#{keyword} a",
' something &&',
' something_else',
'end'])
expect(cop.highlights).to be_empty
end
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, ['until a +',
' b',
' something',
'end'])
expect(new_source).to eq(['until a +',
' b',
' something',
'end'].join("\n"))
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/multiline_ternary_operator_spec.rb 0000664 0000000 0000000 00000001677 13070542236 0030514 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::MultilineTernaryOperator do
subject(:cop) { described_class.new }
it 'registers offense when the if branch and the else branch are ' \
'on a separate line from the condition' do
inspect_source(cop, ['a = cond ?',
' b : c'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense when the false branch is on a separate line' do
inspect_source(cop, ['a = cond ? b :',
' c'].join("\n"))
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense when everything is on a separate line' do
inspect_source(cop, ['a = cond ?',
' b :',
' c'])
expect(cop.offenses.size).to eq(1)
end
it 'accepts a single line ternary operator expression' do
inspect_source(cop, 'a = cond ? b : c')
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/mutable_constant_spec.rb 0000664 0000000 0000000 00000010557 13070542236 0026372 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::MutableConstant do
subject(:cop) { described_class.new }
let(:prefix) { nil }
shared_examples :mutable_objects do |o|
context 'when assigning with =' do
it "registers an offense for #{o} assigned to a constant" do
source = [prefix, "CONST = #{o}"].compact.join("\n")
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'auto-corrects by adding .freeze' do
source = [prefix, "CONST = #{o}"].compact.join("\n")
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{source}.freeze")
end
end
context 'when assigning with ||=' do
it "registers an offense for #{o} assigned to a constant" do
source = [prefix, "CONST ||= #{o}"].compact.join("\n")
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'auto-corrects by adding .freeze' do
source = [prefix, "CONST ||= #{o}"].compact.join("\n")
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{source}.freeze")
end
end
end
it_behaves_like :mutable_objects, '[1, 2, 3]'
it_behaves_like :mutable_objects, '{ a: 1, b: 2 }'
it_behaves_like :mutable_objects, "'str'"
it_behaves_like :mutable_objects, '"top#{1 + 2}"'
shared_examples :immutable_objects do |o|
it "allows #{o} to be assigned to a constant" do
source = [prefix, "CONST = #{o}"].compact.join("\n")
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it "allows #{o} to be ||= to a constant" do
source = [prefix, "CONST ||= #{o}"].compact.join("\n")
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
it_behaves_like :immutable_objects, '1'
it_behaves_like :immutable_objects, '1.5'
it_behaves_like :immutable_objects, ':sym'
it 'allows method call assignments' do
inspect_source(cop, 'TOP_TEST = Something.new')
expect(cop.offenses).to be_empty
end
context 'when performing a splat assignment' do
it 'allows an immutable value' do
inspect_source(cop, 'FOO = *(1...10)')
expect(cop.offenses).to be_empty
end
it 'allows a frozen array value' do
inspect_source(cop, 'FOO = *[1...10].freeze')
expect(cop.offenses).to be_empty
end
it 'registers an offense for a mutable value' do
source = 'BAR = *[1, 2, 3]'
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
corrected = autocorrect_source(cop, source)
expect(corrected).to eq('BAR = *[1, 2, 3].freeze')
end
end
context 'when assigning an array without brackets' do
it 'adds brackets when auto-correcting' do
new_source = autocorrect_source(cop, 'XXX = YYY, ZZZ')
expect(new_source).to eq 'XXX = [YYY, ZZZ].freeze'
end
it 'does not add brackets to %w() arrays' do
new_source = autocorrect_source(cop, 'XXX = %w(YYY ZZZ)')
expect(new_source).to eq 'XXX = %w(YYY ZZZ).freeze'
end
end
context 'when the constant is a frozen string literal' do
if RuboCop::Config::KNOWN_RUBIES.include?(3.0)
context 'when the target ruby version >= 3.0' do
let(:ruby_version) { 3.0 }
context 'when the frozen string literal comment is missing' do
it_behaves_like :immutable_objects, '"#{a}"'
end
context 'when the frozen string literal comment is true' do
let(:prefix) { '# frozen_string_literal: true' }
it_behaves_like :immutable_objects, '"#{a}"'
end
context 'when the frozen string literal comment is false' do
let(:prefix) { '# frozen_string_literal: false' }
it_behaves_like :immutable_objects, '"#{a}"'
end
end
end
context 'when the target ruby version >= 2.3' do
let(:ruby_version) { 2.3 }
context 'when the frozen string literal comment is missing' do
it_behaves_like :mutable_objects, '"#{a}"'
end
context 'when the frozen string literal comment is true' do
let(:prefix) { '# frozen_string_literal: true' }
it_behaves_like :immutable_objects, '"#{a}"'
end
context 'when the frozen string literal comment is false' do
let(:prefix) { '# frozen_string_literal: false' }
it_behaves_like :mutable_objects, '"#{a}"'
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/negated_if_spec.rb 0000664 0000000 0000000 00000015034 13070542236 0025110 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::NegatedIf do
subject(:cop) do
config = RuboCop::Config.new(
'Style/NegatedIf' => {
'SupportedStyles' => %w[both prefix postfix],
'EnforcedStyle' => 'both'
}
)
described_class.new(config)
end
describe 'with “both” style' do
it 'registers an offense for if with exclamation point condition' do
inspect_source(cop,
['if !a_condition',
' some_method',
'end',
'some_method if !a_condition'])
expect(cop.messages).to eq(
['Favor `unless` over `if` for negative ' \
'conditions.'] * 2
)
end
it 'registers an offense for unless with exclamation point condition' do
inspect_source(cop,
['unless !a_condition',
' some_method',
'end',
'some_method unless !a_condition'])
expect(cop.messages).to eq(['Favor `if` over `unless` for negative ' \
'conditions.'] * 2)
end
it 'registers an offense for if with "not" condition' do
inspect_source(cop,
['if not a_condition',
' some_method',
'end',
'some_method if not a_condition'])
expect(cop.messages).to eq(
['Favor `unless` over `if` for negative ' \
'conditions.'] * 2
)
expect(cop.offenses.map(&:line)).to eq([1, 4])
end
it 'accepts an if/else with negative condition' do
inspect_source(cop,
['if !a_condition',
' some_method',
'else',
' something_else',
'end',
'if not a_condition',
' some_method',
'elsif other_condition',
' something_else',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts an if where only part of the condition is negated' do
inspect_source(cop,
['if !condition && another_condition',
' some_method',
'end',
'if not condition or another_condition',
' some_method',
'end',
'some_method if not condition or another_condition'])
expect(cop.offenses).to be_empty
end
it 'accepts an if where the condition is doubly negated' do
inspect_source(cop,
['if !!condition',
' some_method',
'end',
'some_method if !!condition'])
expect(cop.offenses).to be_empty
end
it 'is not confused by negated elsif' do
inspect_source(cop,
['if test.is_a?(String)',
' 3',
'elsif test.is_a?(Array)',
' 2',
'elsif !test.nil?',
' 1',
'end'])
expect(cop.offenses).to be_empty
end
it 'autocorrects for postfix' do
corrected = autocorrect_source(cop, 'bar if !foo')
expect(corrected).to eq 'bar unless foo'
end
it 'autocorrects by replacing if not with unless' do
corrected = autocorrect_source(cop, 'something if !x.even?')
expect(corrected).to eq 'something unless x.even?'
end
it 'autocorrects by replacing parenthesized if not with unless' do
corrected = autocorrect_source(cop, 'something if (!x.even?)')
expect(corrected).to eq 'something unless (x.even?)'
end
it 'autocorrects by replacing unless not with if' do
corrected = autocorrect_source(cop, 'something unless !x.even?')
expect(corrected).to eq 'something if x.even?'
end
it 'autocorrects for prefix' do
corrected = autocorrect_source(cop,
['if !foo',
'end'])
expect(corrected).to eq [
'unless foo',
'end'
].join("\n")
end
end
describe 'with “prefix” style' do
subject(:cop) do
config = RuboCop::Config.new(
'Style/NegatedIf' => {
'SupportedStyles' => %w[both prefix postfix],
'EnforcedStyle' => 'prefix'
}
)
described_class.new(config)
end
it 'registers an offence for prefix' do
inspect_source(cop,
['if !foo',
'end'])
expect(cop.messages).to eq(
['Favor `unless` over `if` for negative conditions.']
)
end
it 'does not register an offence for postfix' do
inspect_source(cop, 'foo if !bar')
expect(cop.offenses).to be_empty
end
it 'autocorrects for prefix' do
corrected = autocorrect_source(cop,
['if !foo',
'end'])
expect(corrected).to eq [
'unless foo',
'end'
].join("\n")
end
end
describe 'with “postfix” style' do
subject(:cop) do
config = RuboCop::Config.new(
'Style/NegatedIf' => {
'SupportedStyles' => %w[both prefix postfix],
'EnforcedStyle' => 'postfix'
}
)
described_class.new(config)
end
it 'registers an offence for postfix' do
inspect_source(cop, 'foo if !bar')
expect(cop.messages).to eq(
['Favor `unless` over `if` for negative conditions.']
)
end
it 'does not register an offence for prefix' do
inspect_source(cop,
['if !foo',
'end'])
expect(cop.offenses).to be_empty
end
it 'autocorrects for postfix' do
corrected = autocorrect_source(cop, 'bar if !foo')
expect(corrected).to eq 'bar unless foo'
end
end
it 'does not blow up for ternary ops' do
inspect_source(cop, 'a ? b : c')
expect(cop.offenses).to be_empty
end
it 'does not blow up on a negated ternary operator' do
inspect_source(cop, '!foo.empty? ? :bar : :baz')
expect(cop.offenses).to be_empty
end
it 'does not blow up for empty if condition' do
inspect_source(cop,
['if ()',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not blow up for empty unless condition' do
inspect_source(cop,
['unless ()',
'end'])
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/negated_while_spec.rb 0000664 0000000 0000000 00000005537 13070542236 0025631 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::NegatedWhile do
subject(:cop) { described_class.new }
it 'registers an offense for while with exclamation point condition' do
inspect_source(cop,
['while !a_condition',
' some_method',
'end',
'some_method while !a_condition'])
expect(cop.messages).to eq(
['Favor `until` over `while` for negative conditions.'] * 2
)
end
it 'registers an offense for until with exclamation point condition' do
inspect_source(cop,
['until !a_condition',
' some_method',
'end',
'some_method until !a_condition'])
expect(cop.messages)
.to eq(['Favor `while` over `until` for negative conditions.'] * 2)
end
it 'registers an offense for while with "not" condition' do
inspect_source(cop,
['while (not a_condition)',
' some_method',
'end',
'some_method while not a_condition'])
expect(cop.messages).to eq(
['Favor `until` over `while` for negative conditions.'] * 2
)
expect(cop.offenses.map(&:line)).to eq([1, 4])
end
it 'accepts a while where only part of the condition is negated' do
inspect_source(cop,
['while !a_condition && another_condition',
' some_method',
'end',
'while not a_condition or another_condition',
' some_method',
'end',
'some_method while not a_condition or other_cond'])
expect(cop.messages).to be_empty
end
it 'accepts a while where the condition is doubly negated' do
inspect_source(cop,
['while !!a_condition',
' some_method',
'end',
'some_method while !!a_condition'])
expect(cop.messages).to be_empty
end
it 'autocorrects by replacing while not with until' do
corrected = autocorrect_source(cop, ['something while !x.even?',
'something while(!x.even?)'])
expect(corrected).to eq ['something until x.even?',
'something until(x.even?)'].join("\n")
end
it 'autocorrects by replacing until not with while' do
corrected = autocorrect_source(cop, 'something until !x.even?')
expect(corrected).to eq 'something while x.even?'
end
it 'does not blow up for empty while condition' do
inspect_source(cop,
['while ()',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not blow up for empty until condition' do
inspect_source(cop,
['until ()',
'end'])
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/nested_modifier_spec.rb 0000664 0000000 0000000 00000005476 13070542236 0026174 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::NestedModifier do
subject(:cop) { described_class.new }
shared_examples 'avoidable' do |keyword|
it "registers an offense for modifier #{keyword}" do
inspect_source(cop, "something #{keyword} a if b")
expect(cop.messages).to eq(['Avoid using nested modifiers.'])
expect(cop.highlights).to eq([keyword])
end
end
shared_examples 'not correctable' do |keyword|
it "does not auto-correct when #{keyword} is the outer modifier" do
source = "something if a #{keyword} b"
corrected = autocorrect_source(cop, source)
expect(corrected).to eq source
expect(cop.offenses.map(&:corrected?)).to eq [false]
end
it "does not auto-correct when #{keyword} is the inner modifier" do
source = "something #{keyword} a if b"
corrected = autocorrect_source(cop, source)
expect(corrected).to eq source
expect(cop.offenses.map(&:corrected?)).to eq [false]
end
end
context 'if' do
it_behaves_like 'avoidable', 'if'
end
context 'unless' do
it_behaves_like 'avoidable', 'unless'
end
it 'auto-corrects if + if' do
corrected = autocorrect_source(cop, 'something if a if b')
expect(corrected).to eq 'something if b && a'
end
it 'auto-corrects unless + unless' do
corrected = autocorrect_source(cop, 'something unless a unless b')
expect(corrected).to eq 'something unless b || a'
end
it 'auto-corrects if + unless' do
corrected = autocorrect_source(cop, 'something if a unless b')
expect(corrected).to eq 'something unless b || !a'
end
it 'auto-corrects unless with a comparison operator + if' do
corrected = autocorrect_source(cop, 'something unless b > 1 if true')
expect(corrected).to eq 'something if true && !(b > 1)'
end
it 'auto-corrects unless + if' do
corrected = autocorrect_source(cop, 'something unless a if b')
expect(corrected).to eq 'something if b && !a'
end
it 'adds parentheses when needed in auto-correction' do
corrected = autocorrect_source(cop, 'something if a || b if c || d')
expect(corrected).to eq 'something if (c || d) && (a || b)'
end
it 'does not add redundant parentheses in auto-correction' do
corrected = autocorrect_source(cop, 'something if a unless c || d')
expect(corrected).to eq 'something unless c || d || !a'
end
context 'while' do
it_behaves_like 'avoidable', 'while'
it_behaves_like 'not correctable', 'while'
end
context 'until' do
it_behaves_like 'avoidable', 'until'
it_behaves_like 'not correctable', 'until'
end
it 'registers one offense for more than two modifiers' do
inspect_source(cop, 'something until a while b unless c if d')
expect(cop.messages).to eq(['Avoid using nested modifiers.'])
expect(cop.highlights).to eq(['unless'])
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/nested_parenthesized_calls_spec.rb 0000664 0000000 0000000 00000005605 13070542236 0030413 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::NestedParenthesizedCalls do
subject(:cop) { described_class.new }
before do
inspect_source(cop, source)
end
context 'on a non-parenthesized method call' do
let(:source) { 'puts 1, 2' }
it "doesn't register an offense" do
expect(cop.offenses).to be_empty
end
end
context 'on a method call with no arguments' do
let(:source) { 'puts' }
it "doesn't register an offense" do
expect(cop.offenses).to be_empty
end
end
context 'on a nested, parenthesized method call' do
let(:source) { 'puts(compute(something))' }
it "doesn't register an offense" do
expect(cop.offenses).to be_empty
end
end
context 'on a non-parenthesized call nested in a parenthesized one' do
context 'with a single argument to the nested call' do
let(:source) { 'puts(compute something)' }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['Add parentheses to nested method call `compute something`.']
)
expect(cop.highlights).to eq(['compute something'])
end
it 'auto-corrects by adding parentheses' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('puts(compute(something))')
end
end
context 'with multiple arguments to the nested call' do
let(:source) { 'puts(compute first, second)' }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['Add parentheses to nested method call `compute first, second`.']
)
expect(cop.highlights).to eq(['compute first, second'])
end
it 'auto-corrects by adding parentheses' do
new_source = autocorrect_source(cop, 'puts(compute first, second)')
expect(new_source).to eq('puts(compute(first, second))')
end
end
end
context 'on a call with no arguments, nested in a parenthesized one' do
let(:source) { 'puts(compute)' }
it "doesn't register an offense" do
expect(cop.offenses).to be_empty
end
end
context 'on an aref, nested in a parenthesized method call' do
let(:source) { 'method(obj[1])' }
it "doesn't register an offense" do
expect(cop.offenses).to be_empty
end
end
context 'on a deeply nested argument' do
let(:source) { 'method(block_taker { another_method 1 })' }
it "doesn't register an offense" do
expect(cop.offenses).to be_empty
end
end
context 'on an RSpec matcher' do
let(:source) { 'expect(obj).to(be true)' }
it "doesn't register an offense" do
expect(cop.offenses).to be_empty
end
end
context 'on a call to a setter method' do
let(:source) { 'expect(object1.attr = 1).to eq 1' }
it "doesn't register an offense" do
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/nested_ternary_operator_spec.rb 0000664 0000000 0000000 00000001105 13070542236 0027756 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::NestedTernaryOperator do
subject(:cop) { described_class.new }
it 'registers an offense for a nested ternary operator expression' do
inspect_source(cop, 'a ? (b ? b1 : b2) : a2')
expect(cop.offenses.size).to eq(1)
end
it 'accepts a non-nested ternary operator within an if' do
inspect_source(cop, ['a = if x',
' cond ? b : c',
'else',
' d',
'end'])
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/next_spec.rb 0000664 0000000 0000000 00000043034 13070542236 0024002 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::Next, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'MinBodyLength' => 1 } }
shared_examples 'iterators' do |condition|
let(:opposite) { condition == 'if' ? 'unless' : 'if' }
it "registers an offense for #{condition} inside of downto" do
inspect_source(cop, ['3.downto(1) do',
" #{condition} o == 1",
' puts o',
' end',
'end'])
expect(cop.messages).to eq(['Use `next` to skip iteration.'])
expect(cop.highlights).to eq(["#{condition} o == 1"])
end
it "autocorrects #{condition} inside of downto" do
new_source = autocorrect_source(cop, ['3.downto(1) do',
" #{condition} o == 1",
' puts o',
' end',
'end'])
expect(new_source).to eq(['3.downto(1) do',
" next #{opposite} o == 1",
' puts o',
'end'].join("\n"))
end
it "registers an offense for #{condition} inside of each" do
inspect_source(cop, ['[].each do |o|',
" #{condition} o == 1",
' puts o',
' end',
'end'])
expect(cop.messages).to eq(['Use `next` to skip iteration.'])
expect(cop.highlights).to eq(["#{condition} o == 1"])
end
it "autocorrects #{condition} inside of each" do
new_source = autocorrect_source(cop, ['[].each do |o|',
" #{condition} o == 1",
' puts o',
' end',
'end'])
expect(new_source).to eq(['[].each do |o|',
" next #{opposite} o == 1",
' puts o',
'end'].join("\n"))
end
it "registers an offense for #{condition} inside of each_with_object" do
inspect_source(cop, ['[].each_with_object({}) do |o, a|',
" #{condition} o == 1",
' a[o] = {}',
' end',
'end'])
expect(cop.messages).to eq(['Use `next` to skip iteration.'])
expect(cop.highlights).to eq(["#{condition} o == 1"])
end
it "registers an offense for #{condition} inside of for" do
inspect_source(cop, ['for o in 1..3 do',
" #{condition} o == 1",
' puts o',
' end',
'end'])
expect(cop.messages).to eq(['Use `next` to skip iteration.'])
expect(cop.highlights).to eq(["#{condition} o == 1"])
end
it "autocorrects #{condition} inside of for" do
new_source = autocorrect_source(cop, ['for o in 1..3 do',
" #{condition} o == 1",
' puts o',
' end',
'end'])
expect(new_source).to eq(['for o in 1..3 do',
" next #{opposite} o == 1",
' puts o',
'end'].join("\n"))
end
it "registers an offense for #{condition} inside of loop" do
inspect_source(cop, ['loop do',
" #{condition} o == 1",
' puts o',
' end',
'end'])
expect(cop.messages).to eq(['Use `next` to skip iteration.'])
expect(cop.highlights).to eq(["#{condition} o == 1"])
end
it "registers an offense for #{condition} inside of map" do
inspect_source(cop, ['loop do',
' {}.map do |k, v|',
" #{condition} v == 1",
' puts k',
' end',
' end',
'end'])
expect(cop.messages).to eq(['Use `next` to skip iteration.'])
expect(cop.highlights).to eq(["#{condition} v == 1"])
end
it "registers an offense for #{condition} inside of times" do
inspect_source(cop, ['loop do',
' 3.times do |o|',
" #{condition} o == 1",
' puts o',
' end',
' end',
'end'])
expect(cop.messages).to eq(['Use `next` to skip iteration.'])
expect(cop.highlights).to eq(["#{condition} o == 1"])
end
it "registers an offense for #{condition} inside of collect" do
inspect_source(cop, ['[].collect do |o|',
" #{condition} o == 1",
' true',
' end',
'end'])
expect(cop.messages).to eq(['Use `next` to skip iteration.'])
expect(cop.highlights).to eq(["#{condition} o == 1"])
end
it "registers an offense for #{condition} inside of select" do
inspect_source(cop, ['[].select do |o|',
" #{condition} o == 1",
' true',
' end',
'end'])
expect(cop.messages).to eq(['Use `next` to skip iteration.'])
expect(cop.highlights).to eq(["#{condition} o == 1"])
end
it "registers an offense for #{condition} inside of select!" do
inspect_source(cop, ['[].select! do |o|',
" #{condition} o == 1",
' true',
' end',
'end'])
expect(cop.messages).to eq(['Use `next` to skip iteration.'])
expect(cop.highlights).to eq(["#{condition} o == 1"])
end
it "registers an offense for #{condition} inside of reject" do
inspect_source(cop, ['[].reject do |o|',
" #{condition} o == 1",
' true',
' end',
'end'])
expect(cop.messages).to eq(['Use `next` to skip iteration.'])
expect(cop.highlights).to eq(["#{condition} o == 1"])
end
it "registers an offense for #{condition} inside of reject!" do
inspect_source(cop, ['[].reject! do |o|',
" #{condition} o == 1",
' true',
' end',
'end'])
expect(cop.messages).to eq(['Use `next` to skip iteration.'])
expect(cop.highlights).to eq(["#{condition} o == 1"])
end
it "registers an offense for #{condition} inside of nested iterators" do
inspect_source(cop, ['loop do',
' until false',
" #{condition} o == 1",
' puts o',
' end',
' end',
'end'])
expect(cop.messages).to eq(['Use `next` to skip iteration.'])
expect(cop.highlights).to eq(["#{condition} o == 1"])
end
it "registers an offense for #{condition} inside of nested iterators" do
inspect_source(cop, ['loop do',
' while true',
" #{condition} o == 1",
' puts o',
' end',
' end',
'end'])
expect(cop.messages).to eq(['Use `next` to skip iteration.'])
expect(cop.highlights).to eq(["#{condition} o == 1"])
end
it 'registers an offense for a condition at the end of an iterator ' \
'when there is more in the iterator than the condition' do
inspect_source(cop, ['[].each do |o|',
' puts o',
" #{condition} o == 1",
' puts o',
' end',
'end'])
expect(cop.messages).to eq(['Use `next` to skip iteration.'])
expect(cop.highlights).to eq(["#{condition} o == 1"])
end
it 'allows loops with conditional break' do
inspect_source(cop, ['loop do',
" puts ''",
" break #{condition} o == 1",
'end'])
expect(cop.offenses).to be_empty
end
it 'allows loops with conditional return' do
inspect_source(cop, ['loop do',
" puts ''",
" return #{condition} o == 1",
'end'])
expect(cop.offenses).to be_empty
end
it "allows loops with #{condition} being the entire body with else" do
inspect_source(cop, ['[].each do |o|',
" #{condition} o == 1",
' puts o',
' else',
" puts 'no'",
' end',
'end'])
expect(cop.offenses).to be_empty
end
it "allows loops with #{condition} with else, nested in another " \
'condition' do
inspect_source(cop, ['[].each do |o|',
' if foo',
" #{condition} o == 1",
' puts o',
' else',
" puts 'no'",
' end',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it "allows loops with #{condition} with else at the end" do
inspect_source(cop, ['[].each do |o|',
' puts o',
" #{condition} o == 1",
' puts o',
' else',
" puts 'no'",
' end',
'end'])
expect(cop.offenses).to be_empty
end
it "reports an offense for #{condition} whose body has 3 lines" do
inspect_source(cop, ['arr.each do |e|',
" #{condition} something",
' work',
' work',
' work',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(["#{condition} something"])
end
context 'EnforcedStyle: skip_modifier_ifs' do
let(:cop_config) do
{ 'EnforcedStyle' => 'skip_modifier_ifs' }
end
it "allows modifier #{condition}" do
inspect_source(cop, ['[].each do |o|',
" puts o #{condition} o == 1",
'end'])
expect(cop.offenses).to be_empty
end
end
context 'EnforcedStyle: always' do
let(:cop_config) do
{ 'EnforcedStyle' => 'always' }
end
let(:opposite) { condition == 'if' ? 'unless' : 'if' }
let(:source) do
['[].each do |o|',
" puts o #{condition} o == 1 # comment",
'end']
end
it "registers an offense for modifier #{condition}" do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `next` to skip iteration.'])
expect(cop.highlights).to eq(["puts o #{condition} o == 1"])
end
it "auto-corrects modifier #{condition}" do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq(['[].each do |o|',
" next #{opposite} o == 1",
' puts o # comment',
'end'].join("\n"))
end
end
end
it 'keeps comments when autocorrecting' do
new_source = autocorrect_source(cop, ['loop do',
' if test # keep me',
' # keep me',
' something # keep me',
' # keep me',
' ',
' end # keep me',
'end'])
expect(new_source).to eq(['loop do',
' next unless test # keep me',
' # keep me',
' something # keep me',
' # keep me',
' ',
' # keep me',
'end'].join("\n"))
end
it 'handles `then` when autocorrecting' do
new_source = autocorrect_source(cop, ['loop do',
' if test then',
' something',
' end',
'end'])
expect(new_source).to eq(['loop do',
' next unless test',
' something',
'end'].join("\n"))
end
it "doesn't reindent heredoc bodies when autocorrecting" do
new_source = autocorrect_source(cop, ['loop do',
' if test',
' str = <<-BLAH',
' this is a heredoc',
' nice eh?',
' BLAH',
' something',
' end',
'end'])
expect(new_source).to eq(['loop do',
' next unless test',
' str = <<-BLAH',
' this is a heredoc',
' nice eh?',
' BLAH',
' something',
'end'].join("\n"))
end
it 'handles nested autocorrections' do
new_source = autocorrect_source(cop, ['loop do',
' if test',
' loop do',
' if test',
' something',
' end',
' end',
' end',
'end'])
expect(new_source).to eq(['loop do',
' next unless test',
' loop do',
' next unless test',
' something',
' end',
'end'].join("\n"))
end
it_behaves_like 'iterators', 'if'
it_behaves_like 'iterators', 'unless'
it 'allows empty blocks' do
inspect_source(cop, ['[].each do',
'end',
'[].each { }'])
expect(cop.offenses).to be_empty
end
it 'allows loops with conditions at the end with ternary op' do
inspect_source(cop, ['[].each do |o|',
' o == x ? y : z',
'end'])
expect(cop.offenses).to be_empty
end
it 'allows super nodes' do
# https://github.com/bbatsov/rubocop/issues/1115
inspect_source(cop, ['def foo',
' super(a, a) { a }',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not blow up on empty body until block' do
inspect_source(cop, 'until sup; end')
expect(cop.offenses).to be_empty
end
it 'does not blow up on empty body while block' do
inspect_source(cop, 'while sup; end')
expect(cop.offenses).to be_empty
end
it 'does not blow up on empty body for block' do
inspect_source(cop, 'for x in y; end')
expect(cop.offenses).to be_empty
end
it 'does not crash with an empty body branch' do
inspect_source(cop, ['loop do',
' if true',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not crash with empty brackets' do
inspect_source(cop, ['loop do',
' ()',
'end'])
expect(cop.offenses).to be_empty
end
context 'MinBodyLength: 3' do
let(:cop_config) do
{ 'MinBodyLength' => 3 }
end
it 'accepts if whose body has 1 line' do
inspect_source(cop, ['arr.each do |e|',
' if something',
' work',
' end',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'Invalid MinBodyLength' do
let(:cop_config) do
{ 'MinBodyLength' => -2 }
end
it 'fails with an error' do
source = ['loop do',
' if o == 1',
' puts o',
' end',
'end']
expect { inspect_source(cop, source) }
.to raise_error('MinBodyLength needs to be a positive integer!')
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/nil_comparison_spec.rb 0000664 0000000 0000000 00000001365 13070542236 0026041 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::NilComparison do
subject(:cop) { described_class.new }
it 'registers an offense for == nil' do
inspect_source(cop, 'x == nil')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['=='])
end
it 'registers an offense for === nil' do
inspect_source(cop, 'x === nil')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['==='])
end
it 'autocorrects by replacing == nil with .nil?' do
corrected = autocorrect_source(cop, 'x == nil')
expect(corrected).to eq 'x.nil?'
end
it 'autocorrects by replacing === nil with .nil?' do
corrected = autocorrect_source(cop, 'x === nil')
expect(corrected).to eq 'x.nil?'
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/non_nil_check_spec.rb 0000664 0000000 0000000 00000012001 13070542236 0025603 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::NonNilCheck, :config do
subject(:cop) { described_class.new(config) }
context 'when not allowing semantic changes' do
let(:cop_config) do
{
'IncludeSemanticChanges' => false
}
end
it 'registers an offense for != nil' do
inspect_source(cop, 'x != nil')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['!='])
expect(cop.messages)
.to eq(['Prefer `!expression.nil?` over `expression != nil`.'])
end
it 'does not register an offense for != 0' do
inspect_source(cop, 'x != 0')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for !x.nil?' do
inspect_source(cop, '!x.nil?')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for not x.nil?' do
inspect_source(cop, 'not x.nil?')
expect(cop.offenses).to be_empty
end
it 'does not register an offense if only expression in predicate' do
inspect_source(cop, ['def signed_in?',
' !current_user.nil?',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense if only expression in class predicate' do
inspect_source(cop, ['def Test.signed_in?',
' current_user != nil',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense if last expression in predicate' do
inspect_source(cop, ['def signed_in?',
' something',
' current_user != nil',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense if last expression in class predicate' do
inspect_source(cop, ['def Test.signed_in?',
' something',
' current_user != nil',
'end'])
expect(cop.offenses).to be_empty
end
it 'autocorrects by changing `!= nil` to `!x.nil?`' do
corrected = autocorrect_source(cop, 'x != nil')
expect(corrected).to eq '!x.nil?'
end
it 'does not autocorrect by removing non-nil (!x.nil?) check' do
corrected = autocorrect_source(cop, '!x.nil?')
expect(corrected).to eq '!x.nil?'
end
it 'does not blow up when autocorrecting implicit receiver' do
corrected = autocorrect_source(cop, '!nil?')
expect(corrected).to eq '!nil?'
end
it 'does not report corrected when the code was not modified' do
source = 'return nil unless (line =~ //) != nil'
corrected = autocorrect_source(cop, source)
expect(corrected).to eq(source)
expect(cop.corrections).to be_empty
end
end
context 'when allowing semantic changes' do
subject(:cop) { described_class.new(config) }
let(:cop_config) do
{
'IncludeSemanticChanges' => true
}
end
it 'registers an offense for `!x.nil?`' do
inspect_source(cop, '!x.nil?')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Explicit non-nil checks are usually redundant.'])
expect(cop.highlights).to eq(['!x.nil?'])
end
it 'registers an offense for unless x.nil?' do
inspect_source(cop, 'puts b unless x.nil?')
expect(cop.messages)
.to eq(['Explicit non-nil checks are usually redundant.'])
expect(cop.highlights).to eq(['x.nil?'])
end
it 'does not register an offense for `x.nil?`' do
inspect_source(cop, 'x.nil?')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for `!x`' do
inspect_source(cop, '!x')
expect(cop.offenses).to be_empty
end
it 'registers an offense for `not x.nil?`' do
inspect_source(cop, 'not x.nil?')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['not x.nil?'])
end
it 'does not blow up with ternary operators' do
inspect_source(cop, 'my_var.nil? ? 1 : 0')
expect(cop.offenses).to be_empty
end
it 'autocorrects by changing unless x.nil? to if x' do
corrected = autocorrect_source(cop, 'puts a unless x.nil?')
expect(corrected).to eq 'puts a if x'
end
it 'autocorrects by changing `x != nil` to `x`' do
corrected = autocorrect_source(cop, 'x != nil')
expect(corrected).to eq 'x'
end
it 'autocorrects by changing `!x.nil?` to `x`' do
corrected = autocorrect_source(cop, '!x.nil?')
expect(corrected).to eq 'x'
end
it 'does not blow up when autocorrecting implicit receiver' do
corrected = autocorrect_source(cop, '!nil?')
expect(corrected).to eq 'self'
end
it 'corrects code that would not be modified if ' \
'IncludeSemanticChanges were false' do
corrected = autocorrect_source(cop,
'return nil unless (line =~ //) != nil')
expect(corrected).to eq('return nil unless (line =~ //)')
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/not_spec.rb 0000664 0000000 0000000 00000003063 13070542236 0023622 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::Not, :config do
subject(:cop) { described_class.new(config) }
it 'registers an offense for not' do
inspect_source(cop, 'not test')
expect(cop.offenses.size).to eq(1)
end
it 'does not register an offense for !' do
inspect_source(cop, '!test')
expect(cop.offenses).to be_empty
end
it 'auto-corrects "not" with !' do
new_source = autocorrect_source(cop, 'x = 10 if not y')
expect(new_source).to eq('x = 10 if !y')
end
it 'auto-corrects "not" followed by parens with !' do
new_source = autocorrect_source(cop, 'not(test)')
expect(new_source).to eq('!(test)')
end
it 'uses the reverse operator when `not` is applied to a comparison' do
src = 'not x < y'
new_source = autocorrect_source(cop, src)
expect(new_source).to eq('x >= y')
end
it 'parenthesizes when `not` would change the meaning of a binary exp' do
src = 'not a >> b'
new_source = autocorrect_source(cop, src)
expect(new_source).to eq('!(a >> b)')
end
it 'parenthesizes when `not` is applied to a ternary op' do
src = 'not a ? b : c'
new_source = autocorrect_source(cop, src)
expect(new_source).to eq('!(a ? b : c)')
end
it 'parenthesizes when `not` is applied to and' do
src = 'not a && b'
new_source = autocorrect_source(cop, src)
expect(new_source).to eq('!(a && b)')
end
it 'parenthesizes when `not` is applied to or' do
src = 'not a || b'
new_source = autocorrect_source(cop, src)
expect(new_source).to eq('!(a || b)')
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/numeric_literal_prefix_spec.rb 0000664 0000000 0000000 00000010553 13070542236 0027557 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::NumericLiteralPrefix, :config do
subject(:cop) { described_class.new(config) }
context 'octal literals' do
context 'when config is zero_with_o' do
let(:cop_config) do
{
'EnforcedOctalStyle' => 'zero_with_o'
}
end
it 'registers an offense for prefixes `0` and `0O`' do
inspect_source(cop, ['a = 01234',
'b(0O1234)'])
expect(cop.offenses.size).to eq(2)
expect(cop.messages.uniq).to eq(['Use 0o for octal literals.'])
expect(cop.highlights).to eq(%w[01234 0O1234])
end
it 'does not register offense for lowercase prefix' do
inspect_source(cop, ['a = 0o101',
'b = 0o567'])
expect(cop.messages).to be_empty
end
it 'autocorrects an octal literal starting with 0' do
corrected = autocorrect_source(cop, ['a = 01234'])
expect(corrected).to eq('a = 0o1234')
end
it 'autocorrects an octal literal starting with 0O' do
corrected = autocorrect_source(cop, ['b(0O1234, a)'])
expect(corrected).to eq('b(0o1234, a)')
end
end
context 'when config is zero_only' do
let(:cop_config) do
{
'EnforcedOctalStyle' => 'zero_only'
}
end
it 'registers an offense for prefix `0O` and `0o`' do
inspect_source(cop, ['a = 0O1234',
'b(0o1234)'])
expect(cop.offenses.size).to eq(2)
expect(cop.messages.uniq).to eq(['Use 0 for octal literals.'])
expect(cop.highlights).to eq(%w[0O1234 0o1234])
end
it 'does not register offense for prefix `0`' do
inspect_source(cop, 'b = 0567')
expect(cop.messages).to be_empty
end
it 'autocorrects an octal literal starting with 0O or 0o' do
corrected = autocorrect_source(cop, ['a = 0O1234',
'b(0o1234)'])
expect(corrected).to eq "a = 01234\nb(01234)"
end
it 'does not autocorrect an octal literal starting with 0' do
corrected = autocorrect_source(cop, ['b(01234, a)'])
expect(corrected).to eq 'b(01234, a)'
end
end
end
context 'hex literals' do
it 'registers an offense for uppercase prefix' do
inspect_source(cop, ['a = 0X1AC',
'b(0XABC)'])
expect(cop.offenses.size).to eq(2)
expect(cop.messages.uniq).to eq(['Use 0x for hexadecimal literals.'])
expect(cop.highlights).to eq(%w[0X1AC 0XABC])
end
it 'does not register offense for lowercase prefix' do
inspect_source(cop, 'a = 0x101')
expect(cop.messages).to be_empty
end
it 'autocorrects literals with uppercase prefix' do
corrected = autocorrect_source(cop, ['a = 0XAB'])
expect(corrected).to eq 'a = 0xAB'
end
end
context 'binary literals' do
it 'registers an offense for uppercase prefix' do
inspect_source(cop, ['a = 0B10101',
'b(0B111)'])
expect(cop.offenses.size).to eq(2)
expect(cop.messages.uniq).to eq(['Use 0b for binary literals.'])
expect(cop.highlights).to eq(%w[0B10101 0B111])
end
it 'does not register offense for lowercase prefix' do
inspect_source(cop, 'a = 0b101')
expect(cop.messages).to be_empty
end
it 'autocorrects literals with uppercase prefix' do
corrected = autocorrect_source(cop, ['a = 0B1010'])
expect(corrected).to eq 'a = 0b1010'
end
end
context 'decimal literals' do
it 'registers an offense for prefixes' do
inspect_source(cop, ['a = 0d1234',
'b(0D1234)'])
expect(cop.offenses.size).to eq(2)
expect(cop.messages.uniq)
.to eq(['Do not use prefixes for decimal literals.'])
expect(cop.highlights).to eq(%w[0d1234 0D1234])
end
it 'does not register offense for no prefix' do
inspect_source(cop, 'a = 101')
expect(cop.messages).to be_empty
end
it 'autocorrects literals with prefix' do
corrected = autocorrect_source(cop, ['a = 0d1234', 'b(0D1990)'])
expect(corrected).to eq "a = 1234\nb(1990)"
end
it 'does not autocorrect literals with no prefix' do
corrected = autocorrect_source(cop, ['a = 1234', 'b(1990)'])
expect(corrected).to eq "a = 1234\nb(1990)"
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/numeric_literals_spec.rb 0000664 0000000 0000000 00000006130 13070542236 0026361 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::NumericLiterals, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'MinDigits' => 5 } }
it 'registers an offense for a long undelimited integer' do
inspect_source(cop, 'a = 12345')
expect(cop.offenses.size).to eq(1)
expect(cop.config_to_allow_offenses).to eq('MinDigits' => 6)
end
it 'registers an offense for a float with a long undelimited integer part' do
inspect_source(cop, 'a = 123456.789')
expect(cop.offenses.size).to eq(1)
expect(cop.config_to_allow_offenses).to eq('MinDigits' => 7)
end
it 'accepts integers with less than three places at the end' do
inspect_source(cop, ['a = 123_456_789_00',
'b = 819_2'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for an integer with misplaced underscore' do
inspect_source(cop, ['a = 123_456_78_90_00',
'b = 1_8192'])
expect(cop.offenses.size).to eq(2)
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'accepts long numbers with underscore' do
inspect_source(cop, ['a = 123_456',
'b = 123_456.55'])
expect(cop.messages).to be_empty
end
it 'accepts a short integer without underscore' do
inspect_source(cop, 'a = 123')
expect(cop.messages).to be_empty
end
it 'does not count a leading minus sign as a digit' do
inspect_source(cop, 'a = -1230')
expect(cop.messages).to be_empty
end
it 'accepts short numbers without underscore' do
inspect_source(cop, ['a = 123',
'b = 123.456'])
expect(cop.messages).to be_empty
end
it 'ignores non-decimal literals' do
inspect_source(cop, ['a = 0b1010101010101',
'b = 01717171717171',
'c = 0xab11111111bb'])
expect(cop.offenses).to be_empty
end
it 'autocorrects a long integer offense' do
corrected = autocorrect_source(cop, ['a = 123456'])
expect(corrected).to eq 'a = 123_456'
end
it 'autocorrects an integer with misplaced underscore' do
corrected = autocorrect_source(cop, ['a = 123_456_78_90_00'])
expect(corrected).to eq 'a = 123_456_789_000'
end
it 'autocorrects negative numbers' do
corrected = autocorrect_source(cop, ['a = -123456'])
expect(corrected).to eq 'a = -123_456'
end
it 'autocorrects floating-point numbers' do
corrected = autocorrect_source(cop, ['a = 123456.78'])
expect(corrected).to eq 'a = 123_456.78'
end
it 'autocorrects negative floating-point numbers' do
corrected = autocorrect_source(cop, ['a = -123456.78'])
expect(corrected).to eq 'a = -123_456.78'
end
context 'strict' do
let(:cop_config) do
{
'MinDigits' => 5,
'Strict' => true
}
end
it 'registers an offense for an integer with misplaced underscore' do
inspect_source(cop, ['a = 123_456_78_90_00',
'b = 81_92'])
expect(cop.offenses.size).to eq(2)
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/numeric_predicate_spec.rb 0000664 0000000 0000000 00000011671 13070542236 0026510 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::NumericPredicate, :config do
subject(:cop) { described_class.new(config) }
before do
inspect_source(cop, source)
end
shared_examples 'code with offense' do |code, expected|
context "when checking #{code}" do
let(:source) { code }
let(:message) { "Use `#{expected}` instead of `#{code}`." }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq([message])
end
if expected
it 'auto-corrects' do
expect(autocorrect_source(cop, code)).to eq(expected)
end
else
it 'does not auto-correct' do
expect(autocorrect_source(cop, code)).to eq(code)
end
end
end
end
shared_examples 'code without offense' do |code|
let(:source) { code }
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
context 'when configured to enforce numeric predicate methods' do
let(:cop_config) do
{ 'EnforcedStyle' => 'predicate', 'AutoCorrect' => true }
end
context 'when checking if a number is zero' do
it_behaves_like 'code with offense',
'number == 0',
'number.zero?'
it_behaves_like 'code with offense',
'0 == number',
'number.zero?'
context 'with a complex expression' do
it_behaves_like 'code with offense',
'foo - 1 == 0',
'(foo - 1).zero?'
it_behaves_like 'code with offense',
'0 == foo - 1',
'(foo - 1).zero?'
end
end
context 'with checking if a number is not zero' do
it_behaves_like 'code without offense',
'number != 0'
it_behaves_like 'code without offense',
'0 != number'
context 'with a complex expression' do
it_behaves_like 'code without offense',
'foo - 1 != 0'
it_behaves_like 'code without offense',
'0 != foo - 1'
end
end
context 'when checking if a number is positive' do
context 'when target ruby version is 2.3 or higher', :ruby23, :ruby24 do
it_behaves_like 'code with offense',
'number > 0',
'number.positive?'
it_behaves_like 'code with offense',
'0 < number',
'number.positive?'
context 'with a complex expression' do
it_behaves_like 'code with offense',
'foo - 1 > 0',
'(foo - 1).positive?'
it_behaves_like 'code with offense',
'0 < foo - 1',
'(foo - 1).positive?'
end
end
context 'when target ruby version is 2.2 or lower', :ruby22 do
it_behaves_like 'code without offense',
'number > 0'
it_behaves_like 'code without offense',
'0 < number'
end
end
context 'when checking if a number is negative' do
context 'when target ruby version is 2.3 or higher', :ruby23, :ruby24 do
it_behaves_like 'code with offense',
'number < 0',
'number.negative?'
it_behaves_like 'code with offense',
'0 > number',
'number.negative?'
context 'with a complex expression' do
it_behaves_like 'code with offense',
'foo - 1 < 0',
'(foo - 1).negative?'
it_behaves_like 'code with offense',
'0 > foo - 1',
'(foo - 1).negative?'
end
end
context 'when target ruby version is 2.2 or lower', :ruby22 do
it_behaves_like 'code without offense',
'number < 0'
it_behaves_like 'code without offense',
'0 > number'
end
end
end
context 'when configured to enforce numeric comparison methods' do
let(:cop_config) do
{ 'EnforcedStyle' => 'comparison', 'AutoCorrect' => true }
end
context 'when checking if a number is zero' do
it_behaves_like 'code with offense',
'number.zero?',
'number == 0'
end
context 'with checking if a number is not zero' do
it_behaves_like 'code without offense',
'number.nonzero?'
end
context 'when checking if a number is positive' do
it_behaves_like 'code with offense',
'number.positive?',
'number > 0'
end
context 'when checking if a number is negative' do
it_behaves_like 'code with offense',
'number.negative?',
'number < 0'
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/one_line_conditional_spec.rb 0000664 0000000 0000000 00000006321 13070542236 0027175 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::OneLineConditional do
subject(:cop) { described_class.new }
shared_examples 'offense' do |condition|
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages)
.to eq(['Favor the ternary operator (`?:`)' \
" over `#{condition}/then/else/end` constructs."])
end
end
shared_examples 'no offense' do
it 'does not register an offense' do
inspect_source(cop, source)
expect(cop.messages).to be_empty
end
end
shared_examples 'autocorrect' do |correct_code|
it 'auto-corrects' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq(correct_code)
end
end
context 'one line if/then/else/end' do
let(:source) { 'if cond then run else dont end' }
include_examples 'offense', 'if'
include_examples 'autocorrect', 'cond ? run : dont'
context 'empty else' do
let(:source) { 'if cond then run else end' }
include_examples 'no offense'
end
end
context 'one line if/then/end' do
let(:source) { 'if cond then run end' }
include_examples 'no offense'
end
context 'one line unless/then/else/end' do
let(:source) { 'unless cond then run else dont end' }
include_examples 'offense', 'unless'
include_examples 'autocorrect', 'cond ? dont : run'
context 'empty else' do
let(:source) { 'unless cond then run else end' }
include_examples 'no offense'
end
end
context 'one line unless/then/end' do
let(:source) { 'unless cond then run end' }
include_examples 'no offense'
end
%w[| ^ & <=> == === =~ > >= < <= << >> + - * / % ** ~ ! != !~
&& ||].each do |operator|
it 'parenthesizes the expression if it is preceded by an operator' do
corrected =
autocorrect_source(cop, "a #{operator} if cond then run else dont end")
expect(corrected).to eq("a #{operator} (cond ? run : dont)")
end
end
shared_examples 'changed precedence' do |expr|
it "adds parentheses around `#{expr}`" do
corrected = autocorrect_source(cop,
"if #{expr} then #{expr} else #{expr} end")
expect(corrected).to eq("(#{expr}) ? (#{expr}) : (#{expr})")
end
end
it_behaves_like 'changed precedence', 'puts 1'
it_behaves_like 'changed precedence', 'defined? :A'
it_behaves_like 'changed precedence', 'yield a'
it_behaves_like 'changed precedence', 'super b'
it_behaves_like 'changed precedence', 'not a'
it_behaves_like 'changed precedence', 'a and b'
it_behaves_like 'changed precedence', 'a or b'
it_behaves_like 'changed precedence', 'a = b'
it_behaves_like 'changed precedence', 'a ? b : c'
it 'does not parenthesize expressions when they do not contain method ' \
'calls with unparenthesized arguments' do
corrected =
autocorrect_source(cop, 'if a(0) then puts(1) else yield(2) end')
expect(corrected).to eq('a(0) ? puts(1) : yield(2)')
end
it 'does not parenthesize expressions when they contain unparenthesized ' \
'operator method calls' do
corrected = autocorrect_source(cop, 'if 0 + 0 then 1 + 1 else 2 + 2 end')
expect(corrected).to eq('0 + 0 ? 1 + 1 : 2 + 2')
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/op_method_spec.rb 0000664 0000000 0000000 00000004533 13070542236 0025003 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::OpMethod do
subject(:cop) { described_class.new }
%i[+ eql? equal?].each do |op|
it "registers an offense for #{op} with arg not named other" do
inspect_source(cop,
["def #{op}(another)",
' another',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(["When defining the `#{op}` operator, " \
'name its argument `other`.'])
end
end
it 'works properly even if the argument not surrounded with braces' do
inspect_source(cop,
['def + another',
' another',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['When defining the `+` operator, name its argument `other`.'])
end
it 'does not register an offense for arg named other' do
inspect_source(cop,
['def +(other)',
' other',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense for arg named _other' do
inspect_source(cop,
['def <=>(_other)',
' 0',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense for []' do
inspect_source(cop,
['def [](index)',
' other',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense for []=' do
inspect_source(cop,
['def []=(index, value)',
' other',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense for <<' do
inspect_source(cop,
['def <<(cop)',
' other',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense for non binary operators' do
inspect_source(cop,
['def -@; end',
# This + is not a unary operator. It can only be
# called with dot notation.
'def +; end',
'def *(a, b); end', # Quite strange, but legal ruby.
'def `(cmd); end'])
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/option_hash_spec.rb 0000664 0000000 0000000 00000003745 13070542236 0025344 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::OptionHash, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'SuspiciousParamNames' => ['options'] } }
let(:source) do
[
'def some_method(options = {})',
' puts some_arg',
'end'
]
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.messages.first)
.to eq('Prefer keyword arguments to options hashes.')
expect(cop.highlights).to eq ['options = {}']
end
context 'when the last argument is an options hash named something else' do
let(:source) do
[
'def steep(flavor, duration, config={})',
' mug = config.fetch(:mug)',
' prep(flavor, duration, mug)',
'end'
]
end
it 'does not register an offense' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'registers an offense when in SuspiciousParamNames list' do
cop_config['SuspiciousParamNames'] = ['config']
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.messages.first)
.to eq('Prefer keyword arguments to options hashes.')
expect(cop.highlights).to eq ['config={}']
end
end
context 'when there are no arguments' do
before do
inspect_source(cop, source)
end
let(:source) do
[
'def meditate',
' puts true',
' puts true',
'end'
]
end
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
context 'when the last argument is a non-options-hash optional hash' do
before do
inspect_source(cop, source)
end
let(:source) do
[
'def cook(instructions, ingredients = { hot: [], cold: [] })',
' prep(ingredients)',
'end'
]
end
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/optional_arguments_spec.rb 0000664 0000000 0000000 00000005742 13070542236 0026742 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::OptionalArguments do
subject(:cop) { described_class.new }
it 'registers an offense when an optional argument is followed by a ' \
'required argument' do
inspect_source(cop, ['def foo(a = 1, b)',
'end'])
expect(cop.messages)
.to eq([described_class::MSG])
expect(cop.highlights).to eq(['a = 1'])
end
it 'registers an offense for each optional argument when multiple ' \
'optional arguments are followed by a required argument' do
inspect_source(cop, ['def foo(a = 1, b = 2, c)',
'end'])
expect(cop.messages).to eq([described_class::MSG, described_class::MSG])
expect(cop.highlights).to eq(['a = 1', 'b = 2'])
end
it 'allows methods without arguments' do
inspect_source(cop, ['def foo',
'end'])
expect(cop.messages).to be_empty
end
it 'allows methods with only one required argument' do
inspect_source(cop, ['def foo(a)',
'end'])
expect(cop.messages).to be_empty
end
it 'allows methods with only required arguments' do
inspect_source(cop, ['def foo(a, b, c)',
'end'])
expect(cop.messages).to be_empty
end
it 'allows methods with only one optional argument' do
inspect_source(cop, ['def foo(a = 1)',
'end'])
expect(cop.messages).to be_empty
end
it 'allows methods with only optional arguments' do
inspect_source(cop, ['def foo(a = 1, b = 2, c = 3)',
'end'])
expect(cop.messages).to be_empty
end
it 'allows methods with multiple optional arguments at the end' do
inspect_source(cop, ['def foo(a, b = 2, c = 3)',
'end'])
expect(cop.messages).to be_empty
end
context 'named params' do
context 'with default values', :ruby20 do
it 'allows optional arguments before an optional named argument' do
inspect_source(cop, ['def foo(a = 1, b: 2)',
'end'])
expect(cop.messages).to be_empty
end
end
context 'required params', :ruby21 do
it 'registers an offense for optional arguments that come before ' \
'required arguments where there are name arguments' do
inspect_source(cop, ['def foo(a = 1, b, c:, d: 4)',
'end'])
expect(cop.messages).to eq([described_class::MSG])
expect(cop.highlights).to eq(['a = 1'])
end
it 'allows optional arguments before required named arguments' do
inspect_source(cop, ['def foo(a = 1, b:)',
'end'])
expect(cop.messages).to be_empty
end
it 'allows optional arguments to come before a mix of required and ' \
'optional named argument' do
inspect_source(cop, ['def foo(a = 1, b:, c: 3)',
'end'])
expect(cop.messages).to be_empty
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/parallel_assignment_spec.rb 0000664 0000000 0000000 00000042626 13070542236 0027056 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::ParallelAssignment, :config do
subject(:cop) { described_class.new(config) }
let(:config) do
RuboCop::Config.new('Style/IndentationWidth' => { 'Width' => 2 })
end
shared_examples('offenses') do |source|
it "registers an offense for: #{source.gsub(/\s*\n\s*/, '; ')}" do
inspect_source(cop, source)
expect(cop.messages).to eq(['Do not use parallel assignment.'])
end
end
it_behaves_like('offenses', 'a, b, c = 1, 2, 3')
it_behaves_like('offenses', 'a, b, c = [1, 2, 3]')
it_behaves_like('offenses', 'a, b, c = [1, 2], [3, 4], [5, 6]')
it_behaves_like('offenses', 'a, b, c = {a: 1}, {b: 2}, {c: 3}')
it_behaves_like('offenses', 'a, b, c = CONSTANT1, CONSTANT2, CONSTANT3')
it_behaves_like('offenses', 'a, b, c = [1, 2], {a: 1}, CONSTANT3')
it_behaves_like('offenses', 'a, b = foo(), bar()')
it_behaves_like('offenses', 'a, b = foo { |a| puts a }, bar()')
it_behaves_like('offenses', 'CONSTANT1, CONSTANT2 = CONSTANT3, CONSTANT4')
it_behaves_like('offenses', 'a, b = 1, 2 if something')
it_behaves_like('offenses', 'a, b = 1, 2 unless something')
it_behaves_like('offenses', 'a, b = 1, 2 while something')
it_behaves_like('offenses', 'a, b = 1, 2 until something')
it_behaves_like('offenses', "a, b = 1, 2 rescue 'Error'")
it_behaves_like('offenses', 'a, b = 1, a')
it_behaves_like('offenses', 'a, b = a, b')
it_behaves_like('offenses',
'a, b = foo.map { |e| e.id }, bar.map { |e| e.id }')
it_behaves_like('offenses', ['array = [1, 2, 3]',
'a, b, c, = 8, 9, array'].join("\n"))
it_behaves_like('offenses', ['if true',
' a, b = 1, 2',
'end'].join("\n"))
it_behaves_like('offenses', 'a, b = Float::INFINITY, Float::INFINITY')
it_behaves_like('offenses', 'Float::INFINITY, Float::INFINITY = 1, 2')
it_behaves_like('offenses', 'a[0], a[1] = a[1], a[2]')
it_behaves_like('offenses', 'obj.attr1, obj.attr2 = obj.attr3, obj.attr1')
it_behaves_like('offenses', 'obj.attr1, ary[0] = ary[1], obj.attr1')
it_behaves_like('offenses', 'a[0], a[1] = a[1], b[0]')
shared_examples('allowed') do |source|
it "allows assignment of: #{source.gsub(/\s*\n\s*/, '; ')}" do
inspect_source(cop, source)
expect(cop.messages).to be_empty
end
end
it_behaves_like('allowed', 'a = 1')
it_behaves_like('allowed', 'a = a')
it_behaves_like('allowed', 'a, = a')
it_behaves_like('allowed', 'a, = 1')
it_behaves_like('allowed', "a = *'foo'")
it_behaves_like('allowed', "a, = *'foo'")
it_behaves_like('allowed', 'a, = 1, 2, 3')
it_behaves_like('allowed', 'a, = *foo')
it_behaves_like('allowed', 'a, *b = [1, 2, 3]')
it_behaves_like('allowed', '*a, b = [1, 2, 3]')
it_behaves_like('allowed', 'a, b = b, a')
it_behaves_like('allowed', 'a, b, c = b, c, a')
it_behaves_like('allowed', 'a, b = (a + b), (a - b)')
it_behaves_like('allowed', 'a, b = foo.map { |e| e.id }')
it_behaves_like('allowed', 'a, b = foo()')
it_behaves_like('allowed', 'a, b = *foo')
it_behaves_like('allowed', 'a, b, c = 1, 2, *node')
it_behaves_like('allowed', 'a, b, c = *node, 1, 2')
it_behaves_like('allowed', 'begin_token, end_token = CONSTANT')
it_behaves_like('allowed', 'CONSTANT, = 1, 2')
it_behaves_like('allowed', ['a = 1',
'b = 2'].join("\n"))
it_behaves_like('allowed', ['foo = [1, 2, 3]',
'a, b, c = foo'].join("\n"))
it_behaves_like('allowed', ['array = [1, 2, 3]',
'a, = array'].join("\n"))
it_behaves_like('allowed', 'a, b = Float::INFINITY')
it_behaves_like('allowed', 'a[0], a[1] = a[1], a[0]')
it_behaves_like('allowed', 'obj.attr1, obj.attr2 = obj.attr2, obj.attr1')
it_behaves_like('allowed', 'obj.attr1, ary[0] = ary[0], obj.attr1')
it_behaves_like('allowed', 'ary[0], ary[1], ary[2] = ary[1], ary[2], ary[0]')
it_behaves_like('allowed', 'self.a, self.b = self.b, self.a')
it_behaves_like('allowed', 'self.a, self.b = b, a')
it 'highlights the entire expression' do
inspect_source(cop, 'a, b = 1, 2')
expect(cop.highlights).to eq(['a, b = 1, 2'])
end
it 'does not highlight the modifier statement' do
inspect_source(cop, 'a, b = 1, 2 if true')
expect(cop.highlights).to eq(['a, b = 1, 2'])
end
describe 'autocorrect' do
it 'corrects when the number of left hand variables matches ' \
'the number of right hand variables' do
new_source = autocorrect_source(cop, 'a, b, c = 1, 2, 3')
expect(new_source).to eq(['a = 1',
'b = 2',
'c = 3'].join("\n"))
end
it 'corrects when the right variable is an array' do
new_source = autocorrect_source(cop, 'a, b, c = ["1", "2", :c]')
expect(new_source).to eq(['a = "1"',
'b = "2"',
'c = :c'].join("\n"))
end
it 'corrects when the right variable is a word array' do
new_source = autocorrect_source(cop, 'a, b, c = %w(1 2 3)')
expect(new_source).to eq(["a = '1'",
"b = '2'",
"c = '3'"].join("\n"))
end
it 'corrects when the right variable is a symbol array' do
new_source = autocorrect_source(cop, 'a, b, c = %i(a b c)')
expect(new_source).to eq(['a = :a',
'b = :b',
'c = :c'].join("\n"))
end
it 'corrects when assigning to method returns' do
new_source = autocorrect_source(cop, 'a, b = foo(), bar()')
expect(new_source).to eq(['a = foo()',
'b = bar()'].join("\n"))
end
it 'corrects when assigning from multiple methods with blocks' do
source = 'a, b = foo() { |c| puts c }, bar() { |d| puts d }'
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['a = foo() { |c| puts c }',
'b = bar() { |d| puts d }'].join("\n"))
end
it 'corrects when using constants' do
source = 'CONSTANT1, CONSTANT2 = CONSTANT3, CONSTANT4'
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['CONSTANT1 = CONSTANT3',
'CONSTANT2 = CONSTANT4'].join("\n"))
end
it 'corrects when the expression is missing spaces' do
new_source = autocorrect_source(cop, 'a,b,c=1,2,3')
expect(new_source).to eq(['a = 1',
'b = 2',
'c = 3'].join("\n"))
end
it 'corrects when using single indentation' do
new_source = autocorrect_source(cop, ['def foo',
' a, b, c = 1, 2, 3',
'end'].join("\n"))
expect(new_source).to eq(['def foo',
' a = 1',
' b = 2',
' c = 3',
'end'].join("\n"))
end
it 'corrects when using nested indentation' do
new_source = autocorrect_source(cop, ['def foo',
' if true',
' a, b, c = 1, 2, 3',
' end',
'end'].join("\n"))
expect(new_source).to eq(['def foo',
' if true',
' a = 1',
' b = 2',
' c = 3',
' end',
'end'].join("\n"))
end
it 'corrects when the expression uses a modifier if statement' do
new_source = autocorrect_source(cop, 'a, b = 1, 2 if foo')
expect(new_source).to eq(['if foo',
' a = 1',
' b = 2',
'end'].join("\n"))
end
it 'corrects when the expression uses a modifier if statement ' \
'inside a method' do
new_source = autocorrect_source(cop, ['def foo',
' a, b = 1, 2 if foo',
'end'])
expect(new_source).to eq(['def foo',
' if foo',
' a = 1',
' b = 2',
' end',
'end'].join("\n"))
end
it 'corrects parallel assignment in if statements' do
new_source = autocorrect_source(cop, ['if foo',
' a, b = 1, 2',
'end'].join("\n"))
expect(new_source).to eq(['if foo',
' a = 1',
' b = 2',
'end'].join("\n"))
end
it 'corrects when the expression uses a modifier unless statement' do
new_source = autocorrect_source(cop, 'a, b = 1, 2 unless foo')
expect(new_source).to eq(['unless foo',
' a = 1',
' b = 2',
'end'].join("\n"))
end
it 'corrects parallel assignment in unless statements' do
new_source = autocorrect_source(cop, ['unless foo',
' a, b = 1, 2',
'end'].join("\n"))
expect(new_source).to eq(['unless foo',
' a = 1',
' b = 2',
'end'].join("\n"))
end
it 'corrects when the expression uses a modifier while statement' do
new_source = autocorrect_source(cop, 'a, b = 1, 2 while foo')
expect(new_source).to eq(['while foo',
' a = 1',
' b = 2',
'end'].join("\n"))
end
it 'corrects parallel assignment in while statements' do
new_source = autocorrect_source(cop, ['while foo',
' a, b = 1, 2',
'end'].join("\n"))
expect(new_source).to eq(['while foo',
' a = 1',
' b = 2',
'end'].join("\n"))
end
it 'corrects when the expression uses a modifier until statement' do
new_source = autocorrect_source(cop, 'a, b = 1, 2 until foo')
expect(new_source).to eq(['until foo',
' a = 1',
' b = 2',
'end'].join("\n"))
end
it 'corrects parallel assignment in until statements' do
new_source = autocorrect_source(cop, ['until foo',
' a, b = 1, 2',
'end'].join("\n"))
expect(new_source).to eq(['until foo',
' a = 1',
' b = 2',
'end'].join("\n"))
end
it 'corrects when the expression uses a modifier rescue statement' do
new_source = autocorrect_source(cop, 'a, b = 1, 2 rescue foo')
expect(new_source).to eq(['begin',
' a = 1',
' b = 2',
'rescue',
' foo',
'end'].join("\n"))
end
it 'corrects parallel assignment inside rescue statements '\
'within method definitions' do
new_source = autocorrect_source(cop, ['def bar',
' a, b = 1, 2',
'rescue',
" 'foo'",
'end'].join("\n"))
expect(new_source).to eq(['def bar',
' a = 1',
' b = 2',
'rescue',
" 'foo'",
'end'].join("\n"))
end
it 'corrects parallel assignment in rescue statements '\
'within begin ... rescue' do
new_source = autocorrect_source(cop, ['begin',
' a, b = 1, 2',
'rescue',
" 'foo'",
'end'].join("\n"))
expect(new_source).to eq(['begin',
' a = 1',
' b = 2',
'rescue',
" 'foo'",
'end'].join("\n"))
end
it 'corrects when the expression uses a modifier rescue statement ' \
'as the only thing inside of a method' do
new_source = autocorrect_source(cop, ['def foo',
' a, b = 1, 2 rescue foo',
'end'])
expect(new_source).to eq(['def foo',
' a = 1',
' b = 2',
'rescue',
' foo',
'end'].join("\n"))
end
it 'corrects when the expression uses a modifier rescue statement ' \
'inside of a method' do
new_source = autocorrect_source(cop, ['def foo',
' a, b = %w(1 2) rescue foo',
' something_else',
'end'])
expect(new_source).to eq(['def foo',
' begin',
" a = '1'",
" b = '2'",
' rescue',
' foo',
' end',
' something_else',
'end'].join("\n"))
end
it 'corrects when assignments must be reordered to avoid changing ' \
'meaning' do
new_source = autocorrect_source(cop, ['a, b, c, d = 1, a + 1, b + 1, ' \
'a + b + c'])
expect(new_source).to eq(['d = a + b + c',
'c = b + 1',
'b = a + 1',
'a = 1'].join("\n"))
end
shared_examples('no correction') do |description, source|
context description do
it "does not change: #{source.gsub(/\s*\n\s*/, '; ')}" do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
end
end
it_behaves_like 'no correction',
'when there are more left variables than right variables',
'a, b, c, d = 1, 2'
it_behaves_like 'no correction',
'when there are more right variables than left variables',
'a, b = 1, 2, 3'
it_behaves_like 'no correction',
'when expanding an assigned variable',
['foo = [1, 2, 3]',
'a, b, c = foo'].join("\n")
describe 'using custom indentation width' do
let(:config) do
RuboCop::Config.new('Performance/ParallelAssignment' => {
'Enabled' => true
},
'Style/IndentationWidth' => {
'Enabled' => true,
'Width' => 3
})
end
it 'works with standard correction' do
new_source = autocorrect_source(cop, 'a, b, c = 1, 2, 3')
expect(new_source).to eq(['a = 1',
'b = 2',
'c = 3'].join("\n"))
end
it 'works with guard clauses' do
new_source = autocorrect_source(cop, 'a, b = 1, 2 if foo')
expect(new_source).to eq(['if foo',
' a = 1',
' b = 2',
'end'].join("\n"))
end
it 'works with rescue' do
new_source = autocorrect_source(cop, 'a, b = 1, 2 rescue foo')
expect(new_source).to eq(['begin',
' a = 1',
' b = 2',
'rescue',
' foo',
'end'].join("\n"))
end
it 'works with nesting' do
new_source = autocorrect_source(cop, ['def foo',
' if true',
' a, b, c = 1, 2, 3',
' end',
'end'].join("\n"))
expect(new_source).to eq(['def foo',
' if true',
' a = 1',
' b = 2',
' c = 3',
' end',
'end'].join("\n"))
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/parentheses_around_condition_spec.rb 0000664 0000000 0000000 00000013325 13070542236 0030763 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::ParenthesesAroundCondition, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'AllowSafeAssignment' => true } }
it 'registers an offense for parentheses around condition' do
inspect_source(cop, ['if (x > 10)',
'elsif (x < 3)',
'end',
'unless (x > 10)',
'end',
'while (x > 10)',
'end',
'until (x > 10)',
'end',
'x += 1 if (x < 10)',
'x += 1 unless (x < 10)',
'x += 1 until (x < 10)',
'x += 1 while (x < 10)'])
expect(cop.offenses.size).to eq(9)
expect(cop.messages.first)
.to eq("Don't use parentheses around the condition of an `if`.")
expect(cop.messages.last)
.to eq("Don't use parentheses around the condition of a `while`.")
end
it 'accepts parentheses if there is no space between the keyword and (.' do
inspect_source(cop, ['if(x > 5) then something end',
'do_something until(x > 5)'])
expect(cop.offenses).to be_empty
end
it 'auto-corrects parentheses around condition' do
corrected = autocorrect_source(cop, ['if (x > 10)',
'elsif (x < 3)',
'end',
'unless (x > 10)',
'end',
'while (x > 10)',
'end',
'until (x > 10)',
'end',
'x += 1 if (x < 10)',
'x += 1 unless (x < 10)',
'x += 1 while (x < 10)',
'x += 1 until (x < 10)'])
expect(corrected).to eq ['if x > 10',
'elsif x < 3',
'end',
'unless x > 10',
'end',
'while x > 10',
'end',
'until x > 10',
'end',
'x += 1 if x < 10',
'x += 1 unless x < 10',
'x += 1 while x < 10',
'x += 1 until x < 10'].join("\n")
end
it 'accepts condition without parentheses' do
inspect_source(cop, ['if x > 10',
'end',
'unless x > 10',
'end',
'while x > 10',
'end',
'until x > 10',
'end',
'x += 1 if x < 10',
'x += 1 unless x < 10',
'x += 1 while x < 10',
'x += 1 until x < 10'])
expect(cop.offenses).to be_empty
end
it 'accepts parentheses around condition in a ternary' do
inspect_source(cop, '(a == 0) ? b : a')
expect(cop.offenses).to be_empty
end
it 'is not confused by leading parentheses in subexpression' do
inspect_source(cop, '(a > b) && other ? one : two')
expect(cop.offenses).to be_empty
end
it 'is not confused by unbalanced parentheses' do
inspect_source(cop, ['if (a + b).c()',
'end'])
expect(cop.offenses).to be_empty
end
%w[rescue if unless while until].each do |op|
it "allows parens if the condition node is a modifier #{op} op" do
inspect_source(cop, ["if (something #{op} top)",
'end'])
expect(cop.offenses).to be_empty
end
end
it 'does not blow up when the condition is a ternary op' do
inspect_source(cop, 'x if (a ? b : c)')
expect(cop.offenses.size).to eq(1)
end
it 'does not blow up for empty if condition' do
inspect_source(cop,
['if ()',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not blow up for empty unless condition' do
inspect_source(cop,
['unless ()',
'end'])
expect(cop.offenses).to be_empty
end
context 'safe assignment is allowed' do
it 'accepts variable assignment in condition surrounded with parentheses' do
inspect_source(cop,
['if (test = 10)',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts element assignment in condition surrounded with parentheses' do
inspect_source(cop,
['if (test[0] = 10)',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts setter in condition surrounded with parentheses' do
inspect_source(cop,
['if (self.test = 10)',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'safe assignment is not allowed' do
let(:cop_config) { { 'AllowSafeAssignment' => false } }
it 'does not accept variable assignment in condition surrounded with ' \
'parentheses' do
inspect_source(cop,
['if (test = 10)',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'does not accept element assignment in condition surrounded with ' \
'parentheses' do
inspect_source(cop,
['if (test[0] = 10)',
'end'])
expect(cop.offenses.size).to eq(1)
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/percent_literal_delimiters_spec.rb 0000664 0000000 0000000 00000027730 13070542236 0030426 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::PercentLiteralDelimiters, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) do
{ 'PreferredDelimiters' => { 'default' => '[]' } }
end
context '`default` override' do
let(:cop_config) do
{
'PreferredDelimiters' => {
'default' => '[]',
'%' => '()'
}
}
end
it 'allows all preferred delimiters to be set with one key' do
inspect_source(cop, '%w[string] + %i[string]')
expect(cop.offenses).to be_empty
end
it 'allows individual preferred delimiters to override `default`' do
inspect_source(cop, '%w[string] + [%(string)]')
expect(cop.offenses).to be_empty
end
end
context 'invalid cop config' do
let(:cop_config) { { 'PreferredDelimiters' => { 'foobar' => '()' } } }
it 'raises an error when invalid configuration is specified' do
expect { inspect_source(cop, '%w[string]') }.to raise_error(ArgumentError)
end
end
context '`%` interpolated string' do
it 'does not register an offense for preferred delimiters' do
inspect_source(cop, '%[string]')
expect(cop.offenses).to be_empty
end
it 'registers an offense for other delimiters' do
inspect_source(cop, '%(string)')
expect(cop.messages).to eq(
['`%`-literals should be delimited by `[` and `]`.']
)
end
it 'does not register an offense for other delimiters ' \
'when containing preferred delimiter characters' do
inspect_source(cop, '%([string])')
expect(cop.offenses).to be_empty
end
it 'registers an offense for other delimiters ' \
'when containing preferred delimiter characters in interpolation' do
inspect_source(cop, '%(#{[1].first})')
expect(cop.messages.size).to eq(1)
end
end
context '`%q` string' do
it 'does not register an offense for preferred delimiters' do
inspect_source(cop, '%q[string]')
expect(cop.offenses).to be_empty
end
it 'registers an offense for other delimiters' do
inspect_source(cop, '%q(string)')
expect(cop.messages).to eq(
['`%q`-literals should be delimited by `[` and `]`.']
)
end
it 'does not register an offense for other delimiters ' \
'when containing preferred delimiter characters' do
inspect_source(cop, '%q([string])')
expect(cop.offenses).to be_empty
end
end
context '`%Q` interpolated string' do
it 'does not register an offense for preferred delimiters' do
inspect_source(cop, '%Q[string]')
expect(cop.offenses).to be_empty
end
it 'registers an offense for other delimiters' do
inspect_source(cop, '%Q(string)')
expect(cop.messages).to eq(
['`%Q`-literals should be delimited by `[` and `]`.']
)
end
it 'does not register an offense for other delimiters ' \
'when containing preferred delimiter characters' do
inspect_source(cop, '%Q([string])')
expect(cop.offenses).to be_empty
end
it 'registers an offense for other delimiters ' \
'when containing preferred delimiter characters in interpolation' do
inspect_source(cop, '%Q(#{[1].first})')
expect(cop.messages.size).to eq(1)
end
end
context '`%w` string array' do
it 'does not register an offense for preferred delimiters' do
inspect_source(cop, '%w[some words]')
expect(cop.offenses).to be_empty
end
it 'registers an offense for other delimiters' do
inspect_source(cop, '%w(some words)')
expect(cop.messages).to eq(
['`%w`-literals should be delimited by `[` and `]`.']
)
end
it 'does not register an offense for other delimiters ' \
'when containing preferred delimiter characters' do
inspect_source(cop, '%w([some] [words])')
expect(cop.offenses).to be_empty
end
end
context '`%W` interpolated string array' do
it 'does not register an offense for preferred delimiters' do
inspect_source(cop, '%W[some words]')
expect(cop.offenses).to be_empty
end
it 'registers an offense for other delimiters' do
inspect_source(cop, '%W(some words)')
expect(cop.messages).to eq(
['`%W`-literals should be delimited by `[` and `]`.']
)
end
it 'does not register an offense for other delimiters ' \
'when containing preferred delimiter characters' do
inspect_source(cop, '%W([some] [words])')
expect(cop.offenses).to be_empty
end
it 'registers an offense for other delimiters ' \
'when containing preferred delimiter characters in interpolation' do
inspect_source(cop, '%W(#{[1].first})')
expect(cop.messages.size).to eq(1)
end
end
context '`%r` interpolated regular expression' do
it 'does not register an offense for preferred delimiters' do
inspect_source(cop, '%r[regexp]')
expect(cop.offenses).to be_empty
end
it 'registers an offense for other delimiters' do
inspect_source(cop, '%r(regexp)')
expect(cop.messages).to eq(
['`%r`-literals should be delimited by `[` and `]`.']
)
end
it 'does not register an offense for other delimiters ' \
'when containing preferred delimiter characters' do
inspect_source(cop, '%r([regexp])')
expect(cop.offenses).to be_empty
end
it 'registers an offense for other delimiters ' \
'when containing preferred delimiter characters in interpolation' do
inspect_source(cop, '%r(#{[1].first})')
expect(cop.messages.size).to eq(1)
end
end
context '`%i` symbol array' do
it 'does not register an offense for preferred delimiters' do
inspect_source(cop, '%i[some symbols]')
expect(cop.offenses).to be_empty
end
it 'registers an offense for other delimiters' do
inspect_source(cop, '%i(some symbols)')
expect(cop.messages).to eq(
['`%i`-literals should be delimited by `[` and `]`.']
)
end
end
context '`%I` interpolated symbol array' do
it 'does not register an offense for preferred delimiters' do
inspect_source(cop, '%I[some words]')
expect(cop.offenses).to be_empty
end
it 'registers an offense for other delimiters' do
inspect_source(cop, '%I(some words)')
expect(cop.messages).to eq(
['`%I`-literals should be delimited by `[` and `]`.']
)
end
it 'registers an offense for other delimiters ' \
'when containing preferred delimiter characters in interpolation' do
inspect_source(cop, '%I(#{[1].first})')
expect(cop.messages).to eq(
['`%I`-literals should be delimited by `[` and `]`.']
)
end
end
context '`%s` symbol' do
it 'does not register an offense for preferred delimiters' do
inspect_source(cop, '%s[symbol]')
expect(cop.offenses).to be_empty
end
it 'registers an offense for other delimiters' do
inspect_source(cop, '%s(symbol)')
expect(cop.messages).to eq(
['`%s`-literals should be delimited by `[` and `]`.']
)
end
end
context '`%x` interpolated system call' do
it 'does not register an offense for preferred delimiters' do
inspect_source(cop, '%x[command]')
expect(cop.offenses).to be_empty
end
it 'registers an offense for other delimiters' do
inspect_source(cop, '%x(command)')
expect(cop.messages).to eq(
['`%x`-literals should be delimited by `[` and `]`.']
)
end
it 'does not register an offense for other delimiters ' \
'when containing preferred delimiter characters' do
inspect_source(cop, '%x([command])')
expect(cop.offenses).to be_empty
end
it 'registers an offense for other delimiters ' \
'when containing preferred delimiter characters in interpolation' do
inspect_source(cop, '%x(#{[1].first})')
expect(cop.messages.size).to eq(1)
end
end
context 'auto-correct' do
it 'fixes a string' do
new_source = autocorrect_source(cop, '%(string)')
expect(new_source).to eq('%[string]')
end
it 'fixes a string with no content' do
new_source = autocorrect_source(cop, '%()')
expect(new_source).to eq('%[]')
end
it 'fixes a string array' do
new_source = autocorrect_source(cop, '%w(some words)')
expect(new_source).to eq('%w[some words]')
end
it 'fixes a string array in a scope' do
new_source = autocorrect_source(cop, ['module Foo',
' class Bar',
' def baz',
' %(one two)',
' end',
' end',
' end'])
expect(new_source).to eq(['module Foo',
' class Bar',
' def baz',
' %[one two]',
' end',
' end',
' end'].join("\n"))
end
it 'fixes a regular expression' do
original_source = '%r(.*)'
new_source = autocorrect_source(cop, original_source)
expect(new_source).to eq('%r[.*]')
end
it 'fixes a string with interpolation' do
original_source = '%Q|#{with_interpolation}|'
new_source = autocorrect_source(cop, original_source)
expect(new_source).to eq('%Q[#{with_interpolation}]')
end
it 'fixes a regular expression with interpolation' do
original_source = '%r|#{with_interpolation}|'
new_source = autocorrect_source(cop, original_source)
expect(new_source).to eq('%r[#{with_interpolation}]')
end
it 'fixes a regular expression with option' do
original_source = '%r(.*)i'
new_source = autocorrect_source(cop, original_source)
expect(new_source).to eq('%r[.*]i')
end
it 'preserves line breaks when fixing a multiline array' do
new_source = autocorrect_source(cop, ['%w(', 'some', 'words', ')'])
expect(new_source).to eq(['%w[',
'some',
'words',
']'].join("\n"))
end
it 'preserves indentation when correcting a multiline array' do
original_source = [
' array = %w(',
' first',
' second',
' )'
]
corrected_source = [
' array = %w[',
' first',
' second',
' ]'
].join("\n")
new_source = autocorrect_source(cop, original_source)
expect(new_source).to eq(corrected_source)
end
it 'preserves irregular indentation when correcting a multiline array' do
original_source = [
' array = %w(',
' first',
' second',
')'
]
corrected_source = [
' array = %w[',
' first',
' second',
']'
].join("\n")
new_source = autocorrect_source(cop, original_source)
expect(new_source).to eq(corrected_source)
end
shared_examples :escape_characters do |percent_literal|
it "corrects #{percent_literal} with \\n in it" do
new_source = autocorrect_source(cop, "#{percent_literal}{\n}")
expect(new_source).to eq("#{percent_literal}[\n]")
end
it "corrects #{percent_literal} with \\t in it" do
new_source = autocorrect_source(cop, "#{percent_literal}{\t}")
expect(new_source).to eq("#{percent_literal}[\t]")
end
end
it_behaves_like(:escape_characters, '%')
it_behaves_like(:escape_characters, '%q')
it_behaves_like(:escape_characters, '%Q')
it_behaves_like(:escape_characters, '%s')
it_behaves_like(:escape_characters, '%w')
it_behaves_like(:escape_characters, '%W')
it_behaves_like(:escape_characters, '%x')
it_behaves_like(:escape_characters, '%r')
context 'symbol array', :ruby20 do
it_behaves_like(:escape_characters, '%i')
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/percent_q_literals_spec.rb 0000664 0000000 0000000 00000006535 13070542236 0026710 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::PercentQLiterals, :config do
subject(:cop) { described_class.new(config) }
shared_examples 'accepts quote characters' do
it 'accepts single quotes' do
inspect_source(cop, "'hi'")
expect(cop.offenses).to be_empty
end
it 'accepts double quotes' do
inspect_source(cop, '"hi"')
expect(cop.offenses).to be_empty
end
end
shared_examples 'accepts any q string with backslash t' do
context 'with special characters' do
it 'accepts %q' do
inspect_source(cop, '%q(\t)')
expect(cop.offenses).to be_empty
end
it 'accepts %Q' do
inspect_source(cop, '%Q(\t)')
expect(cop.offenses).to be_empty
end
end
end
context 'when EnforcedStyle is lower_case_q' do
let(:cop_config) { { 'EnforcedStyle' => 'lower_case_q' } }
context 'without interpolation' do
it 'accepts %q' do
inspect_source(cop, '%q(hi)')
expect(cop.offenses).to be_empty
end
it 'registers offense for %Q' do
inspect_source(cop, '%Q(hi)')
expect(cop.messages)
.to eq(['Do not use `%Q` unless interpolation is needed. Use `%q`.'])
expect(cop.highlights).to eq(['%Q('])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, '%Q(hi)')
expect(new_source).to eq('%q(hi)')
end
include_examples 'accepts quote characters'
include_examples 'accepts any q string with backslash t'
end
context 'with interpolation' do
it 'accepts %Q' do
inspect_source(cop, '%Q(#{1 + 2})')
expect(cop.offenses).to be_empty
end
it 'accepts %q' do
# This is most probably a mistake, but not this cop's responsibility.
inspect_source(cop, '%q(#{1 + 2})')
expect(cop.offenses).to be_empty
end
include_examples 'accepts quote characters'
end
end
context 'when EnforcedStyle is upper_case_q' do
let(:cop_config) { { 'EnforcedStyle' => 'upper_case_q' } }
context 'without interpolation' do
it 'registers offense for %q' do
inspect_source(cop, '%q(hi)')
expect(cop.messages).to eq(['Use `%Q` instead of `%q`.'])
expect(cop.highlights).to eq(['%q('])
end
it 'accepts %Q' do
inspect_source(cop, '%Q(hi)')
expect(cop.offenses).to be_empty
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, '%q[hi]')
expect(new_source).to eq('%Q[hi]')
end
include_examples 'accepts quote characters'
include_examples 'accepts any q string with backslash t'
end
context 'with interpolation' do
it 'accepts %Q' do
inspect_source(cop, '%Q(#{1 + 2})')
expect(cop.offenses).to be_empty
end
it 'accepts %q' do
# It's strange if interpolation syntax appears inside a static string,
# but we can't be sure if it's a mistake or not. Changing it to %Q
# would alter semantics, so we leave it as it is.
inspect_source(cop, '%q(#{1 + 2})')
expect(cop.offenses).to be_empty
end
it 'does not auto-correct' do
source = '%q(#{1 + 2})'
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
include_examples 'accepts quote characters'
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/perl_backrefs_spec.rb 0000664 0000000 0000000 00000001070 13070542236 0025620 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::PerlBackrefs do
subject(:cop) { described_class.new }
it 'registers an offense for $1' do
inspect_source(cop, 'puts $1')
expect(cop.offenses.size).to eq(1)
end
it 'auto-corrects $1 to Regexp.last_match[1]' do
new_source = autocorrect_source(cop, '$1')
expect(new_source).to eq('Regexp.last_match(1)')
end
it 'auto-corrects #$1 to #{Regexp.last_match[1]}' do
new_source = autocorrect_source(cop, '"#$1"')
expect(new_source).to eq('"#{Regexp.last_match(1)}"')
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/predicate_name_spec.rb 0000664 0000000 0000000 00000004237 13070542236 0025766 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::PredicateName, :config do
subject(:cop) { described_class.new(config) }
context 'with blacklisted prefixes' do
let(:cop_config) do
{ 'NamePrefix' => %w[has_ is_],
'NamePrefixBlacklist' => %w[has_ is_] }
end
%w[has is].each do |prefix|
it 'registers an offense when method name starts with known prefix' do
inspect_source(cop, ["def #{prefix}_attr",
' # ...',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(["Rename `#{prefix}_attr` to `attr?`."])
expect(cop.highlights).to eq(["#{prefix}_attr"])
end
end
it 'accepts method name that starts with unknown prefix' do
inspect_source(cop, ['def have_attr',
' # ...',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'without blacklisted prefixes' do
let(:cop_config) do
{ 'NamePrefix' => %w[has_ is_], 'NamePrefixBlacklist' => [] }
end
%w[has is].each do |prefix|
it 'registers an offense when method name starts with known prefix' do
inspect_source(cop, ["def #{prefix}_attr",
' # ...',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(["Rename `#{prefix}_attr` to `#{prefix}_attr?`."])
expect(cop.highlights).to eq(["#{prefix}_attr"])
end
end
it 'accepts method name that starts with unknown prefix' do
inspect_source(cop, ['def have_attr',
' # ...',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with whitelisted predicate names' do
let(:cop_config) do
{ 'NamePrefix' => %w[is_], 'NamePrefixBlacklist' => %w[is_],
'NameWhitelist' => %w[is_a?] }
end
it 'accepts method name which is in whitelist' do
inspect_source(cop, ['def is_a?',
' # ...',
'end'])
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/preferred_hash_methods_spec.rb 0000664 0000000 0000000 00000005236 13070542236 0027532 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::PreferredHashMethods, :config do
subject(:cop) { described_class.new(config) }
context 'with enforced `short` style' do
let(:cop_config) { { 'EnforcedStyle' => 'short' } }
it 'registers an offense for has_key? with one arg' do
inspect_source(cop,
'o.has_key?(o)')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `Hash#key?` instead of `Hash#has_key?`.'])
end
it 'accepts has_key? with no args' do
inspect_source(cop,
'o.has_key?')
expect(cop.offenses).to be_empty
end
it 'registers an offense for has_value? with one arg' do
inspect_source(cop,
'o.has_value?(o)')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `Hash#value?` instead of `Hash#has_value?`.'])
end
it 'accepts has_value? with no args' do
inspect_source(cop,
'o.has_value?')
expect(cop.offenses).to be_empty
end
it 'auto-corrects has_key? with key?' do
new_source = autocorrect_source(cop, 'hash.has_key?(:test)')
expect(new_source).to eq('hash.key?(:test)')
end
it 'auto-corrects has_value? with value?' do
new_source = autocorrect_source(cop, 'hash.has_value?(value)')
expect(new_source).to eq('hash.value?(value)')
end
end
context 'with enforced `verbose` style' do
let(:cop_config) { { 'EnforcedStyle' => 'verbose' } }
it 'registers an offense for key? with one arg' do
inspect_source(cop,
'o.key?(o)')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `Hash#has_key?` instead of `Hash#key?`.'])
end
it 'accepts key? with no args' do
inspect_source(cop,
'o.key?')
expect(cop.offenses).to be_empty
end
it 'registers an offense for value? with one arg' do
inspect_source(cop,
'o.value?(o)')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `Hash#has_value?` instead of `Hash#value?`.'])
end
it 'accepts value? with no args' do
inspect_source(cop,
'o.value?')
expect(cop.offenses).to be_empty
end
it 'auto-corrects key? with has_key?' do
new_source = autocorrect_source(cop, 'hash.key?(:test)')
expect(new_source).to eq('hash.has_key?(:test)')
end
it 'auto-corrects value? with has_value?' do
new_source = autocorrect_source(cop, 'hash.value?(value)')
expect(new_source).to eq('hash.has_value?(value)')
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/proc_spec.rb 0000664 0000000 0000000 00000001256 13070542236 0023767 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::Proc do
subject(:cop) { described_class.new }
it 'registers an offense for a Proc.new call' do
inspect_source(cop, 'f = Proc.new { |x| puts x }')
expect(cop.offenses.size).to eq(1)
end
it 'accepts the proc method' do
inspect_source(cop, 'f = proc { |x| puts x }')
expect(cop.offenses).to be_empty
end
it 'accepts the Proc.new call outside of block' do
inspect_source(cop, 'p = Proc.new')
expect(cop.offenses).to be_empty
end
it 'auto-corrects Proc.new to proc' do
corrected = autocorrect_source(cop, ['Proc.new { test }'])
expect(corrected).to eq 'proc { test }'
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/raise_args_spec.rb 0000664 0000000 0000000 00000013567 13070542236 0025153 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::RaiseArgs, :config do
subject(:cop) { described_class.new(config) }
context 'when enforced style is compact' do
let(:cop_config) { { 'EnforcedStyle' => 'compact' } }
context 'with a raise with 2 args' do
it 'reports an offense' do
inspect_source(cop, 'raise RuntimeError, msg')
expect(cop.offenses.size).to eq(1)
expect(cop.config_to_allow_offenses)
.to eq('EnforcedStyle' => 'exploded')
end
it 'auto-corrects to compact style' do
new_source = autocorrect_source(cop, 'raise RuntimeError, msg')
expect(new_source).to eq('raise RuntimeError.new(msg)')
end
end
context 'with correct + opposite' do
it 'reports an offense' do
inspect_source(cop, ['if a',
' raise RuntimeError, msg',
'else',
' raise Ex.new(msg)',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Provide an exception object as an argument to `raise`.'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'auto-corrects to compact style' do
new_source = autocorrect_source(cop, ['if a',
' raise RuntimeError, msg',
'else',
' raise Ex.new(msg)',
'end'])
expect(new_source).to eq(['if a',
' raise RuntimeError.new(msg)',
'else',
' raise Ex.new(msg)',
'end'].join("\n"))
end
end
context 'with a raise with 3 args' do
it 'reports an offense' do
inspect_source(cop, 'raise RuntimeError, msg, caller')
expect(cop.offenses.size).to eq(1)
end
it 'auto-corrects to compact style' do
new_source = autocorrect_source(cop,
['raise RuntimeError, msg, caller'])
expect(new_source).to eq('raise RuntimeError.new(msg, caller)')
end
end
it 'accepts a raise with msg argument' do
inspect_source(cop, 'raise msg')
expect(cop.offenses).to be_empty
end
it 'accepts a raise with an exception argument' do
inspect_source(cop, 'raise Ex.new(msg)')
expect(cop.offenses).to be_empty
end
end
context 'when enforced style is exploded' do
let(:cop_config) { { 'EnforcedStyle' => 'exploded' } }
context 'with a raise with exception object' do
context 'with one argument' do
it 'reports an offense' do
inspect_source(cop, 'raise Ex.new(msg)')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Provide an exception class and message ' \
'as arguments to `raise`.'])
expect(cop.config_to_allow_offenses)
.to eq('EnforcedStyle' => 'compact')
end
it 'auto-corrects to exploded style' do
new_source = autocorrect_source(cop, ['raise Ex.new(msg)'])
expect(new_source).to eq('raise Ex, msg')
end
end
context 'with no arguments' do
it 'reports an offense' do
inspect_source(cop, 'raise Ex.new')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Provide an exception class and message ' \
'as arguments to `raise`.'])
expect(cop.config_to_allow_offenses)
.to eq('EnforcedStyle' => 'compact')
end
it 'auto-corrects to exploded style' do
new_source = autocorrect_source(cop, ['raise Ex.new'])
expect(new_source).to eq('raise Ex')
end
end
end
context 'with opposite + correct' do
it 'reports an offense for opposite + correct' do
inspect_source(cop, ['if a',
' raise RuntimeError, msg',
'else',
' raise Ex.new(msg)',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'auto-corrects to exploded style' do
new_source = autocorrect_source(cop, ['if a',
' raise RuntimeError, msg',
'else',
' raise Ex.new(msg)',
'end'])
expect(new_source).to eq(['if a',
' raise RuntimeError, msg',
'else',
' raise Ex, msg',
'end'].join("\n"))
end
end
it 'accepts exception constructor with more than 1 argument' do
inspect_source(cop, 'raise MyCustomError.new(a1, a2, a3)')
expect(cop.offenses).to be_empty
end
it 'accepts exception constructor with keyword arguments' do
inspect_source(cop, 'raise MyKwArgError.new(a: 1, b: 2)')
expect(cop.offenses).to be_empty
end
it 'accepts a raise with splatted arguments' do
inspect_source(cop, 'raise MyCustomError.new(*args)')
expect(cop.offenses).to be_empty
end
it 'accepts a raise with 3 args' do
inspect_source(cop, 'raise RuntimeError, msg, caller')
expect(cop.offenses).to be_empty
end
it 'accepts a raise with 2 args' do
inspect_source(cop, 'raise RuntimeError, msg')
expect(cop.offenses).to be_empty
end
it 'accepts a raise with msg argument' do
inspect_source(cop, 'raise msg')
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/redundant_begin_spec.rb 0000664 0000000 0000000 00000007616 13070542236 0026162 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::RedundantBegin do
subject(:cop) { described_class.new }
it 'reports an offense for single line def with redundant begin block' do
src = ' def func; begin; x; y; rescue; z end end'
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'reports an offense for def with redundant begin block' do
src = ['def func',
' begin',
' ala',
' rescue => e',
' bala',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'reports an offense for defs with redundant begin block' do
src = ['def Test.func',
' begin',
' ala',
' rescue => e',
' bala',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'accepts a def with required begin block' do
src = ['def func',
' begin',
' ala',
' rescue => e',
' bala',
' end',
' something',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'accepts a defs with required begin block' do
src = ['def Test.func',
' begin',
' ala',
' rescue => e',
' bala',
' end',
' something',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'auto-corrects source separated by newlines ' \
'by removing redundant begin blocks' do
src = [' def func',
' begin',
' foo',
' bar',
' rescue',
' baz',
' end',
' end'].join("\n")
result_src = [' def func',
' ',
' foo',
' bar',
' rescue',
' baz',
' ',
' end'].join("\n")
new_source = autocorrect_source(cop, src)
expect(new_source).to eq(result_src)
end
it 'auto-corrects source separated by semicolons ' \
'by removing redundant begin blocks' do
src = ' def func; begin; x; y; rescue; z end end'
result_src = ' def func; ; x; y; rescue; z end'
new_source = autocorrect_source(cop, src)
expect(new_source).to eq(result_src)
end
it "doesn't modify spacing when auto-correcting" do
src = ['def method',
' begin',
' BlockA do |strategy|',
' foo',
' end',
'',
' BlockB do |portfolio|',
' foo',
' end',
'',
' rescue => e # some problem',
' bar',
' end',
'end']
result_src = ['def method',
' ',
' BlockA do |strategy|',
' foo',
' end',
'',
' BlockB do |portfolio|',
' foo',
' end',
'',
' rescue => e # some problem',
' bar',
' ',
'end'].join("\n")
new_source = autocorrect_source(cop, src)
expect(new_source).to eq(result_src)
end
it 'auto-corrects when there are trailing comments' do
src = ['def method',
' begin # comment 1',
' do_some_stuff',
' rescue # comment 2',
' end # comment 3',
'end']
result_src = ['def method',
' # comment 1',
' do_some_stuff',
' rescue # comment 2',
' # comment 3',
'end'].join("\n")
new_source = autocorrect_source(cop, src)
expect(new_source).to eq(result_src)
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/redundant_exception_spec.rb 0000664 0000000 0000000 00000004452 13070542236 0027067 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::RedundantException do
subject(:cop) { described_class.new }
shared_examples 'common behavior' do |keyword|
it "reports an offense for a #{keyword} with RuntimeError" do
src = "#{keyword} RuntimeError, msg"
inspect_source(cop, src)
expect(cop.highlights).to eq([src])
expect(cop.messages)
.to eq(['Redundant `RuntimeError` argument can be removed.'])
end
it "reports an offense for a #{keyword} with RuntimeError.new" do
src = "#{keyword} RuntimeError.new(msg)"
inspect_source(cop, src)
expect(cop.highlights).to eq([src])
expect(cop.messages)
.to eq(['Redundant `RuntimeError.new` call can be replaced with ' \
'just the message.'])
end
it "accepts a #{keyword} with RuntimeError if it does not have 2 args" do
inspect_source(cop, "#{keyword} RuntimeError, msg, caller")
expect(cop.offenses).to be_empty
end
it "auto-corrects a #{keyword} RuntimeError by removing RuntimeError" do
src = "#{keyword} RuntimeError, msg"
result_src = "#{keyword} msg"
new_src = autocorrect_source(cop, src)
expect(new_src).to eq(result_src)
end
it "auto-corrects a #{keyword} RuntimeError.new with parentheses by " \
'removing RuntimeError.new' do
src = "#{keyword} RuntimeError.new(msg)"
result_src = "#{keyword} msg"
new_src = autocorrect_source(cop, src)
expect(new_src).to eq(result_src)
end
it "auto-corrects a #{keyword} RuntimeError.new without parentheses by " \
'removing RuntimeError.new' do
src = "#{keyword} RuntimeError.new msg"
result_src = "#{keyword} msg"
new_src = autocorrect_source(cop, src)
expect(new_src).to eq(result_src)
end
it "does not modify #{keyword} w/ RuntimeError if it does not have 2 " \
'args' do
src = "#{keyword} runtimeError, msg, caller"
new_src = autocorrect_source(cop, src)
expect(new_src).to eq(src)
end
it 'does not modify rescue w/ non redundant error' do
src = "#{keyword} OtherError, msg"
new_src = autocorrect_source(cop, src)
expect(new_src).to eq(src)
end
end
include_examples 'common behavior', 'raise'
include_examples 'common behavior', 'fail'
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/redundant_freeze_spec.rb 0000664 0000000 0000000 00000005404 13070542236 0026347 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::RedundantFreeze do
subject(:cop) { described_class.new }
let(:prefix) { nil }
shared_examples :immutable_objects do |o|
it "registers an offense for frozen #{o}" do
source = [prefix, "CONST = #{o}.freeze"].compact.join("\n")
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'auto-corrects by removing .freeze' do
source = [prefix, "CONST = #{o}.freeze"].compact.join("\n")
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source.chomp('.freeze'))
end
end
it_behaves_like :immutable_objects, '1'
it_behaves_like :immutable_objects, '1.5'
it_behaves_like :immutable_objects, ':sym'
it_behaves_like :immutable_objects, ':""'
it_behaves_like :immutable_objects, '/./'
it_behaves_like :immutable_objects, '1..5'
shared_examples :mutable_objects do |o|
it "allows #{o} with freeze" do
source = [prefix, "CONST = #{o}.freeze"].compact.join("\n")
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
it_behaves_like :mutable_objects, '[1, 2, 3]'
it_behaves_like :mutable_objects, '{ a: 1, b: 2 }'
it_behaves_like :mutable_objects, "'str'"
it_behaves_like :mutable_objects, '"top#{1 + 2}"'
it 'allows .freeze on method call' do
inspect_source(cop, 'TOP_TEST = Something.new.freeze')
expect(cop.offenses).to be_empty
end
context 'when the receiver is a frozen string literal' do
if RuboCop::Config::KNOWN_RUBIES.include?(3.0)
context 'when the target ruby version >= 3.0' do
let(:ruby_version) { 3.0 }
context 'when the frozen string literal comment is missing' do
it_behaves_like :immutable_objects, '"#{a}"'
end
context 'when the frozen string literal comment is true' do
let(:prefix) { '# frozen_string_literal: true' }
it_behaves_like :immutable_objects, '"#{a}"'
end
context 'when the frozen string literal comment is false' do
let(:prefix) { '# frozen_string_literal: false' }
it_behaves_like :immutable_objects, '"#{a}"'
end
end
end
context 'when the target ruby version >= 2.3' do
let(:ruby_version) { 2.3 }
context 'when the frozen string literal comment is missing' do
it_behaves_like :mutable_objects, '"#{a}"'
end
context 'when the frozen string literal comment is true' do
let(:prefix) { '# frozen_string_literal: true' }
it_behaves_like :immutable_objects, '"#{a}"'
end
context 'when the frozen string literal comment is false' do
let(:prefix) { '# frozen_string_literal: false' }
it_behaves_like :mutable_objects, '"#{a}"'
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/redundant_parentheses_spec.rb 0000664 0000000 0000000 00000022027 13070542236 0027410 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::RedundantParentheses do
subject(:cop) { described_class.new }
shared_examples 'redundant' do |expr, correct, type, highlight = nil|
it "registers an offense for parentheses around #{type}" do
inspect_source(cop, expr)
expect(cop.messages)
.to eq(["Don't use parentheses around #{type}."])
expect(cop.highlights).to eq([highlight || expr])
end
it 'auto-corrects' do
expect(autocorrect_source(cop, expr)).to eq correct
end
end
shared_examples 'plausible' do |expr|
it 'accepts parentheses when arguments are unparenthesized' do
inspect_source(cop, expr)
expect(cop.offenses).to be_empty
end
end
shared_examples 'keyword with return value' do |keyword|
it_behaves_like 'redundant', "(#{keyword})", keyword, 'a keyword'
it_behaves_like 'redundant', "(#{keyword}())", "#{keyword}()", 'a keyword'
it_behaves_like 'redundant', "(#{keyword}(1))", "#{keyword}(1)", 'a keyword'
it_behaves_like 'plausible', "(#{keyword} 1, 2)"
end
shared_examples 'keyword with arguments' do |keyword|
it_behaves_like 'redundant', "(#{keyword})", keyword, 'a keyword'
it_behaves_like 'redundant', "(#{keyword}())", "#{keyword}()", 'a keyword'
it_behaves_like 'redundant', "(#{keyword}(1, 2))", "#{keyword}(1, 2)",
'a keyword'
it_behaves_like 'plausible', "(#{keyword} 1, 2)"
end
it_behaves_like 'redundant', '("x")', '"x"', 'a literal'
it_behaves_like 'redundant', '("#{x}")', '"#{x}"', 'a literal'
it_behaves_like 'redundant', '(:x)', ':x', 'a literal'
it_behaves_like 'redundant', '(:"#{x}")', ':"#{x}"', 'a literal'
it_behaves_like 'redundant', '(1)', '1', 'a literal'
it_behaves_like 'redundant', '(1.2)', '1.2', 'a literal'
it_behaves_like 'redundant', '({})', '{}', 'a literal'
it_behaves_like 'redundant', '([])', '[]', 'a literal'
it_behaves_like 'redundant', '(nil)', 'nil', 'a literal'
it_behaves_like 'redundant', '(true)', 'true', 'a literal'
it_behaves_like 'redundant', '(false)', 'false', 'a literal'
it_behaves_like 'redundant', '(/regexp/)', '/regexp/', 'a literal'
it_behaves_like 'redundant', '("x"; "y")', '"x"; "y"', 'a literal'
it_behaves_like 'redundant', '(1; 2)', '1; 2', 'a literal'
if RUBY_VERSION >= '2.1'
it_behaves_like 'redundant', '(1i)', '1i', 'a literal'
it_behaves_like 'redundant', '(1r)', '1r', 'a literal'
end
it_behaves_like 'redundant', '(__FILE__)', '__FILE__', 'a keyword'
it_behaves_like 'redundant', '(__LINE__)', '__LINE__', 'a keyword'
it_behaves_like 'redundant', '(__ENCODING__)', '__ENCODING__', 'a keyword'
it_behaves_like 'redundant', '(redo)', 'redo', 'a keyword'
it_behaves_like 'redundant', '(retry)', 'retry', 'a keyword'
it_behaves_like 'redundant', '(self)', 'self', 'a keyword'
it_behaves_like 'keyword with return value', 'break'
it_behaves_like 'keyword with return value', 'next'
it_behaves_like 'keyword with return value', 'return'
it_behaves_like 'keyword with arguments', 'super'
it_behaves_like 'keyword with arguments', 'yield'
it_behaves_like 'redundant', '(defined?(:A))', 'defined?(:A)', 'a keyword'
it_behaves_like 'plausible', '(defined? :A)'
it_behaves_like 'plausible', '(alias a b)'
it_behaves_like 'plausible', '(not 1)'
it_behaves_like 'plausible', '(a until b)'
it_behaves_like 'plausible', '(a while b)'
it_behaves_like 'redundant', 'x = 1; (x)', 'x = 1; x', 'a variable', '(x)'
it_behaves_like 'redundant', '(@x)', '@x', 'a variable'
it_behaves_like 'redundant', '(@@x)', '@@x', 'a variable'
it_behaves_like 'redundant', '($x)', '$x', 'a variable'
it_behaves_like 'redundant', '(X)', 'X', 'a constant'
it_behaves_like 'redundant', '(x)', 'x', 'a method call'
it_behaves_like 'redundant', '(x(1, 2))', 'x(1, 2)', 'a method call'
it_behaves_like 'redundant', '("x".to_sym)', '"x".to_sym', 'a method call'
it_behaves_like 'redundant', '(x[:y])', 'x[:y]', 'a method call'
it_behaves_like 'redundant', '("foo"[0])', '"foo"[0]', 'a method call'
it_behaves_like 'redundant', '(["foo"][0])', '["foo"][0]', 'a method call'
it_behaves_like 'redundant', '({0 => :a}[0])', '{0 => :a}[0]', 'a method call'
it_behaves_like 'redundant', '(x; y)', 'x; y', 'a method call'
it_behaves_like 'redundant', '(!x)', '!x', 'an unary operation'
it_behaves_like 'redundant', '(~x)', '~x', 'an unary operation'
it_behaves_like 'redundant', '(-x)', '-x', 'an unary operation'
it_behaves_like 'redundant', '(+x)', '+x', 'an unary operation'
it_behaves_like 'plausible', '(!x.m arg)'
it_behaves_like 'plausible', '(!x).y'
it_behaves_like 'plausible', '-(1.foo)'
it_behaves_like 'plausible', '+(1.foo)'
it_behaves_like 'plausible', '-(1.foo.bar)'
it_behaves_like 'plausible', '+(1.foo.bar)'
it_behaves_like 'plausible', '()'
it_behaves_like 'redundant', '[(1)]', '[1]', 'a literal', '(1)'
it_behaves_like 'redundant', "[(1\n)]", "[1\n]", 'a literal', "(1\n)"
it_behaves_like 'plausible', "[(1\n),]"
it_behaves_like 'redundant', '{a: (1)}', '{a: 1}', 'a literal', '(1)'
it_behaves_like 'redundant', "{a: (1\n)}", "{a: 1\n}", 'a literal', "(1\n)"
it_behaves_like 'plausible', "{a: (1\n),}"
it_behaves_like 'redundant', '(0)**2', '0**2', 'a literal', '(0)'
it_behaves_like 'redundant', '(2)**2', '2**2', 'a literal', '(2)'
it_behaves_like 'redundant', '(2.1)**2', '2.1**2', 'a literal', '(2.1)'
it_behaves_like 'redundant', '2**(-2)', '2**-2', 'a literal', '(-2)'
it_behaves_like 'redundant', '2**(2)', '2**2', 'a literal', '(2)'
it_behaves_like 'plausible', '(-2)**2'
it_behaves_like 'plausible', '(-2.1)**2'
it_behaves_like 'plausible', 'x = (foo; bar)'
it_behaves_like 'plausible', 'x += (foo; bar)'
it_behaves_like 'plausible', 'x + (foo; bar)'
it_behaves_like 'plausible', 'x((foo; bar))'
it_behaves_like 'redundant', <<-END, <<-END2, 'a method call', '(foo; bar)'
def x
(foo; bar)
end
END
def x
foo; bar
end
END2
it_behaves_like 'redundant', <<-END, <<-END2, 'a method call', '(foo; bar)'
def x
baz
(foo; bar)
end
END
def x
baz
foo; bar
end
END2
it_behaves_like 'redundant', <<-END, <<-END2, 'a method call', '(foo; bar)'
x do
(foo; bar)
end
END
x do
foo; bar
end
END2
it_behaves_like 'redundant', <<-END, <<-END2, 'a method call', '(foo; bar)'
x do
baz
(foo; bar)
end
END
x do
baz
foo; bar
end
END2
it 'accepts parentheses around a method call with unparenthesized ' \
'arguments' do
inspect_source(cop, '(a 1, 2) && (1 + 1)')
expect(cop.offenses).to be_empty
end
it 'accepts parentheses inside an irange' do
inspect_source(cop, '(a)..(b)')
expect(cop.offenses).to be_empty
end
it 'accepts parentheses inside an erange' do
inspect_source(cop, '(a)...(b)')
expect(cop.offenses).to be_empty
end
it 'accepts parentheses around an irange' do
inspect_source(cop, '(a..b)')
expect(cop.offenses).to be_empty
end
it 'accepts parentheses around an erange' do
inspect_source(cop, '(a...b)')
expect(cop.offenses).to be_empty
end
it 'accepts parentheses around operator keywords' do
inspect_source(cop, '(1 and 2) and (3 or 4)')
expect(cop.offenses).to be_empty
end
it 'registers an offense when there is space around the parentheses' do
inspect_source(cop, 'if x; y else (1) end')
expect(cop.offenses.size).to eq 1
end
it 'accepts parentheses when they touch the preceding keyword' do
inspect_source(cop, 'if x; y else(1) end')
expect(cop.offenses).to be_empty
end
it 'accepts parentheses when they touch the following keyword' do
inspect_source(cop, 'if x; y else (1)end')
expect(cop.offenses).to be_empty
end
context 'when a hash literal is the first argument in a method call' do
it 'accepts parentheses if the argument list is not parenthesized ' do
inspect_source(cop, 'x ({ y: 1 }), z')
expect(cop.offenses).to be_empty
end
it 'registers an offense if the argument list is parenthesized ' do
inspect_source(cop, 'x(({ y: 1 }), z)')
expect(cop.offenses.size).to eq 1
end
end
context 'when a hash literal is the second argument in a method call' do
it 'registers an offense' do
inspect_source(cop, 'x ({ y: 1 }), ({ y: 1 })')
expect(cop.offenses.size).to eq 1
end
end
context 'when a non-parenthesized call has an arg and a block' do
it 'accepts parens around the arg' do
inspect_source(cop, 'method (:arg) { blah }')
expect(cop.offenses).to be_empty
end
end
it 'accepts parentheses around the error passed to rescue' do
inspect_source(cop, ['begin',
' some_method',
'rescue(StandardError)',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts parentheses around a constant passed to when' do
source = ['case foo',
'when(Const)',
' bar',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/redundant_return_spec.rb 0000664 0000000 0000000 00000020670 13070542236 0026410 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::RedundantReturn, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'AllowMultipleReturnValues' => false } }
it 'reports an offense for def with only a return' do
src = ['def func',
' return something',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'reports an offense for defs with only a return' do
src = ['def Test.func',
' return something',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'reports an offense for def ending with return' do
src = ['def func',
' one',
' two',
' return something',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'reports an offense for defs ending with return' do
src = ['def self.func',
' one',
' two',
' return something',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'accepts return in a non-final position' do
src = ['def func',
' return something if something_else',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'does not blow up on empty method body' do
src = ['def func',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'does not blow up on empty if body' do
src = ['def func',
' if x',
' elsif y',
' else',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'auto-corrects by removing redundant returns' do
src = ['def func',
' one',
' two',
' return something',
'end'].join("\n")
result_src = ['def func',
' one',
' two',
' something',
'end'].join("\n")
new_source = autocorrect_source(cop, src)
expect(new_source).to eq(result_src)
end
context 'when return has no arguments' do
shared_examples 'common behavior' do |ret|
let(:src) do
['def func',
' one',
' two',
" #{ret}",
' # comment',
'end']
end
it "registers an offense for #{ret}" do
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it "auto-corrects by replacing #{ret} with nil" do
new_source = autocorrect_source(cop, src)
expect(new_source).to eq(['def func',
' one',
' two',
' nil',
' # comment',
'end'].join("\n"))
end
end
it_behaves_like 'common behavior', 'return'
it_behaves_like 'common behavior', 'return()'
end
context 'when multi-value returns are not allowed' do
it 'reports an offense for def with only a return' do
src = ['def func',
' return something, test',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'reports an offense for defs with only a return' do
src = ['def Test.func',
' return something, test',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'reports an offense for def ending with return' do
src = ['def func',
' one',
' two',
' return something, test',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'reports an offense for defs ending with return' do
src = ['def self.func',
' one',
' two',
' return something, test',
'end']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'auto-corrects by making implicit arrays explicit' do
src = ['def func',
' return 1, 2',
'end'].join("\n")
result_src = ['def func',
' [1, 2]', # Just 1, 2 is not valid Ruby.
'end'].join("\n")
new_source = autocorrect_source(cop, src)
expect(new_source).to eq(result_src)
end
it 'auto-corrects removes return when using an explicit hash' do
src = ['def func',
' return {:a => 1, :b => 2}',
'end'].join("\n")
result_src = ['def func',
' {:a => 1, :b => 2}', # :a => 1, :b => 2 is not valid Ruby
'end'].join("\n")
new_source = autocorrect_source(cop, src)
expect(new_source).to eq(result_src)
end
it 'auto-corrects by making an implicit hash explicit' do
src = ['def func',
' return :a => 1, :b => 2',
'end'].join("\n")
result_src = ['def func',
' {:a => 1, :b => 2}', # :a => 1, :b => 2 is not valid Ruby
'end'].join("\n")
new_source = autocorrect_source(cop, src)
expect(new_source).to eq(result_src)
end
end
context 'when multi-value returns are allowed' do
let(:cop_config) { { 'AllowMultipleReturnValues' => true } }
it 'accepts def with only a return' do
src = ['def func',
' return something, test',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'accepts defs with only a return' do
src = ['def Test.func',
' return something, test',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'accepts def ending with return' do
src = ['def func',
' one',
' two',
' return something, test',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'accepts defs ending with return' do
src = ['def self.func',
' one',
' two',
' return something, test',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'does not auto-correct' do
src = ['def func',
' return 1, 2',
'end'].join("\n")
new_source = autocorrect_source(cop, src)
expect(new_source).to eq(src)
end
end
context 'when return is inside an if-branch' do
let(:src) do
['def func',
' if x',
' return 1',
' elsif y',
' return 2',
' else',
' return 3',
' end',
'end']
end
it 'registers an offense' do
inspect_source(cop, src)
expect(cop.offenses.size).to eq 3
end
it 'auto-corrects' do
corrected = autocorrect_source(cop, src)
expect(corrected).to eq ['def func',
' if x',
' 1',
' elsif y',
' 2',
' else',
' 3',
' end',
'end'].join("\n")
end
end
context 'when return is inside a when-branch' do
let(:src) do
['def func',
' case x',
' when y then return 1',
' when z then return 2',
' when q',
' else',
' return 3',
' end',
'end']
end
it 'registers an offense' do
inspect_source(cop, src)
expect(cop.offenses.size).to eq 3
end
it 'auto-corrects' do
corrected = autocorrect_source(cop, src)
expect(corrected).to eq ['def func',
' case x',
' when y then 1',
' when z then 2',
' when q',
' else',
' 3',
' end',
'end'].join("\n")
end
end
context 'when case nodes are empty' do
let(:src) do
['def func',
' case x',
' when y then 1',
' when z # do nothing',
' else',
' 3',
' end',
'end']
end
it 'accepts empty when nodes' do
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/redundant_self_spec.rb 0000664 0000000 0000000 00000014361 13070542236 0026022 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::RedundantSelf do
subject(:cop) { described_class.new }
it 'reports an offense a self receiver on an rvalue' do
src = 'a = self.b'
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'does not report an offense when receiver and lvalue have the same name' do
src = 'a = self.a'
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'accepts a self receiver on an lvalue of an assignment' do
src = 'self.a = b'
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'accepts a self receiver on an lvalue of a parallel assignment' do
src = 'a, self.b = c, d'
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'accepts a self receiver on an lvalue of an or-assignment' do
src = 'self.logger ||= Rails.logger'
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'accepts a self receiver on an lvalue of an and-assignment' do
src = 'self.flag &&= value'
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'accepts a self receiver on an lvalue of a plus-assignment' do
src = 'self.sum += 10'
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'accepts a self receiver with the square bracket operator' do
src = 'self[a]'
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'accepts a self receiver with the double less-than operator' do
src = 'self << a'
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'accepts a self receiver for methods named like ruby keywords' do
src = ['a = self.class',
'self.for(deps, [], true)',
'self.and(other)',
'self.or(other)',
'self.alias',
'self.begin',
'self.break',
'self.case',
'self.def',
'self.defined?',
'self.do',
'self.else',
'self.elsif',
'self.end',
'self.ensure',
'self.false',
'self.if',
'self.in',
'self.module',
'self.next',
'self.nil',
'self.not',
'self.redo',
'self.rescue',
'self.retry',
'self.return',
'self.self',
'self.super',
'self.then',
'self.true',
'self.undef',
'self.unless',
'self.until',
'self.when',
'self.while',
'self.yield']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
describe 'instance methods' do
it 'accepts a self receiver used to distinguish from blockarg' do
src = ['def requested_specs(&groups)',
' some_method(self.groups)',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'accepts a self receiver used to distinguish from argument' do
src = ['def requested_specs(groups)',
' some_method(self.groups)',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'accepts a self receiver used to distinguish from optional argument' do
src = ['def requested_specs(final = true)',
' something if self.final != final',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'accepts a self receiver used to distinguish from local variable' do
src = ['def requested_specs',
' @requested_specs ||= begin',
' groups = self.groups - Bundler.settings.without',
' groups.map! { |g| g.to_sym }',
' specs_for(groups)',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'accepts a self receiver used to distinguish from an argument' do
src = ['def foo(bar)',
' puts bar, self.bar',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'accepts a self receiver used to distinguish from an argument' \
' when an inner method is defined' do
src = ['def foo(bar)',
' def inner_method(); end',
' puts bar, self.bar',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
end
describe 'class methods' do
it 'accepts a self receiver used to distinguish from blockarg' do
src = ['def self.requested_specs(&groups)',
' some_method(self.groups)',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'accepts a self receiver used to distinguish from argument' do
src = ['def self.requested_specs(groups)',
' some_method(self.groups)',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'accepts a self receiver used to distinguish from optional argument' do
src = ['def self.requested_specs(final = true)',
' something if self.final != final',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'accepts a self receiver used to distinguish from local variable' do
src = ['def self.requested_specs',
' @requested_specs ||= begin',
' groups = self.groups - Bundler.settings.without',
' groups.map! { |g| g.to_sym }',
' specs_for(groups)',
' end',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
end
it 'accepts a self receiver used to distinguish from constant' do
src = 'self.Foo'
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'accepts a self receiver of .()' do
src = 'self.()'
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'reports an offence a self receiver of .call' do
src = 'self.call'
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'auto-corrects by removing redundant self' do
new_source = autocorrect_source(cop, 'self.x')
expect(new_source).to eq('x')
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/regexp_literal_spec.rb 0000664 0000000 0000000 00000030127 13070542236 0026031 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::RegexpLiteral, :config do
subject(:cop) { described_class.new(config) }
let(:config) do
supported_styles = {
'SupportedStyles' => %w[slashes percent_r mixed]
}
RuboCop::Config.new('Style/PercentLiteralDelimiters' =>
percent_literal_delimiters_config,
'Style/RegexpLiteral' =>
cop_config.merge(supported_styles))
end
let(:percent_literal_delimiters_config) do
{ 'PreferredDelimiters' => { '%r' => '{}' } }
end
describe 'when regex contains slashes in interpolation' do
let(:cop_config) { { 'EnforcedStyle' => 'slashes' } }
it 'ignores the slashes that do not belong // regex' do
inspect_source(cop, 'x =~ /\s{#{x[/\s+/].length}}/')
expect(cop.offenses).to be_empty
end
end
describe '%r regex with other delimiters than curly braces' do
let(:cop_config) { { 'EnforcedStyle' => 'slashes' } }
it 'registers an offense' do
inspect_source(cop, '%r_ls_')
expect(cop.messages).to eq(['Use `//` around regular expression.'])
end
end
describe 'when PercentLiteralDelimiters is configured with brackets' do
let(:cop_config) { { 'EnforcedStyle' => 'percent_r' } }
let(:percent_literal_delimiters_config) do
{ 'PreferredDelimiters' => { '%r' => '[]' } }
end
it 'respects the configuration when auto-correcting' do
new_source = autocorrect_source(cop, '/a/')
expect(new_source).to eq('%r[a]')
end
end
context 'when EnforcedStyle is set to slashes' do
let(:cop_config) { { 'EnforcedStyle' => 'slashes' } }
describe 'a single-line `//` regex without slashes' do
let(:source) { 'foo = /a/' }
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
describe 'a single-line `//` regex with slashes' do
let(:source) { 'foo = /home\//' }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `%r` around regular expression.'])
end
it 'cannot auto-correct' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
describe 'when configured to allow inner slashes' do
before { cop_config['AllowInnerSlashes'] = true }
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
describe 'a multi-line `//` regex without slashes' do
let(:source) do
['foo = /',
' foo',
' bar',
'/x']
end
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
describe 'a multi-line `//` regex with slashes' do
let(:source) do
['foo = /',
' https?:\/\/',
' example\.com',
'/x']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `%r` around regular expression.'])
end
it 'cannot auto-correct' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source.join("\n"))
end
describe 'when configured to allow inner slashes' do
before { cop_config['AllowInnerSlashes'] = true }
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
describe 'a single-line %r regex without slashes' do
let(:source) { 'foo = %r{a}' }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `//` around regular expression.'])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('foo = /a/')
end
end
describe 'a single-line %r regex with slashes' do
let(:source) { 'foo = %r{home/}' }
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
describe 'when configured to allow inner slashes' do
before { cop_config['AllowInnerSlashes'] = true }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `//` around regular expression.'])
end
it 'cannot auto-correct' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
end
end
describe 'a multi-line %r regex without slashes' do
let(:source) do
['foo = %r{',
' foo',
' bar',
'}x']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `//` around regular expression.'])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("foo = /\n foo\n bar\n/x")
end
end
describe 'a multi-line %r regex with slashes' do
let(:source) do
['foo = %r{',
' https?://',
' example\.com',
'}x']
end
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
describe 'when configured to allow inner slashes' do
before { cop_config['AllowInnerSlashes'] = true }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `//` around regular expression.'])
end
it 'cannot auto-correct' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source.join("\n"))
end
end
end
end
context 'when EnforcedStyle is set to percent_r' do
let(:cop_config) { { 'EnforcedStyle' => 'percent_r' } }
describe 'a single-line `//` regex without slashes' do
let(:source) { 'foo = /a/' }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `%r` around regular expression.'])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('foo = %r{a}')
end
end
describe 'a single-line `//` regex with slashes' do
let(:source) { 'foo = /home\//' }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `%r` around regular expression.'])
end
it 'cannot auto-correct' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
end
describe 'a multi-line `//` regex without slashes' do
let(:source) do
['foo = /',
' foo',
' bar',
'/x']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `%r` around regular expression.'])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("foo = %r{\n foo\n bar\n}x")
end
end
describe 'a multi-line `//` regex with slashes' do
let(:source) do
['foo = /',
' https?:\/\/',
' example\.com',
'/x']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `%r` around regular expression.'])
end
it 'cannot auto-correct' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source.join("\n"))
end
end
describe 'a single-line %r regex without slashes' do
let(:source) { 'foo = %r{a}' }
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
describe 'a single-line %r regex with slashes' do
let(:source) { 'foo = %r{home/}' }
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
describe 'a multi-line %r regex without slashes' do
let(:source) do
['foo = %r{',
' foo',
' bar',
'}x']
end
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
describe 'a multi-line %r regex with slashes' do
let(:source) do
['foo = %r{',
' https?://',
' example\.com',
'}x']
end
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
context 'when EnforcedStyle is set to mixed' do
let(:cop_config) { { 'EnforcedStyle' => 'mixed' } }
describe 'a single-line `//` regex without slashes' do
let(:source) { 'foo = /a/' }
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
describe 'a single-line `//` regex with slashes' do
let(:source) { 'foo = /home\//' }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `%r` around regular expression.'])
end
it 'cannot auto-correct' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
describe 'when configured to allow inner slashes' do
before { cop_config['AllowInnerSlashes'] = true }
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
describe 'a multi-line `//` regex without slashes' do
let(:source) do
['foo = /',
' foo',
' bar',
'/x']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `%r` around regular expression.'])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("foo = %r{\n foo\n bar\n}x")
end
end
describe 'a multi-line `//` regex with slashes' do
let(:source) do
['foo = /',
' https?:\/\/',
' example\.com',
'/x']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `%r` around regular expression.'])
end
it 'cannot auto-correct' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source.join("\n"))
end
end
describe 'a single-line %r regex without slashes' do
let(:source) { 'foo = %r{a}' }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `//` around regular expression.'])
end
it 'auto-corrects' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('foo = /a/')
end
end
describe 'a single-line %r regex with slashes' do
let(:source) { 'foo = %r{home/}' }
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
describe 'when configured to allow inner slashes' do
before { cop_config['AllowInnerSlashes'] = true }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages).to eq(['Use `//` around regular expression.'])
end
it 'cannot auto-correct' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source)
end
end
end
describe 'a multi-line %r regex without slashes' do
let(:source) do
['foo = %r{',
' foo',
' bar',
'}x']
end
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
describe 'a multi-line %r regex with slashes' do
let(:source) do
['foo = %r{',
' https?://',
' example\.com',
'}x']
end
it 'is accepted' do
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/rescue_ensure_alignment_spec.rb 0000664 0000000 0000000 00000010120 13070542236 0027717 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::RescueEnsureAlignment do
subject(:cop) { described_class.new }
shared_examples 'common behavior' do |keyword|
context 'bad alignment' do
it 'registers an offense when used with begin' do
inspect_source(cop, ['begin',
' something',
" #{keyword}",
' error',
'end'])
expect(cop.messages).to eq(["`#{keyword}` at 3, 4 is not aligned with" \
' `end` at 5, 0.'])
end
it 'registers an offense when used with def' do
inspect_source(cop, ['def test',
' something',
" #{keyword}",
' error',
'end'])
expect(cop.messages).to eq(["`#{keyword}` at 3, 4 is not aligned with" \
' `end` at 5, 0.'])
end
it 'registers an offense when used with defs' do
inspect_source(cop, ['def Test.test',
' something',
" #{keyword}",
' error',
'end'])
expect(cop.messages).to eq(["`#{keyword}` at 3, 4 is not aligned with" \
' `end` at 5, 0.'])
end
it 'registers an offense when used with class' do
inspect_source(cop, ['class C',
' something',
" #{keyword}",
' error',
'end'])
expect(cop.messages).to eq(["`#{keyword}` at 3, 4 is not aligned with" \
' `end` at 5, 0.'])
end
it 'registers an offense when used with module' do
inspect_source(cop, ['module M',
' something',
" #{keyword}",
' error',
'end'])
expect(cop.messages).to eq(["`#{keyword}` at 3, 4 is not aligned with" \
' `end` at 5, 0.'])
end
it 'accepts rescue and ensure on the same line' do
inspect_source(cop, 'begin; puts 1; rescue; ensure; puts 2; end')
expect(cop.messages).to be_empty
end
it 'auto-corrects' do
corrected = autocorrect_source(cop, ['begin',
' something',
" #{keyword}",
' error',
'end'])
expect(corrected).to eq ['begin',
' something',
keyword,
' error',
'end'].join("\n")
end
end
it 'accepts correct alignment' do
inspect_source(cop, ['begin',
' something',
keyword,
' error',
'end'])
expect(cop.messages).to be_empty
end
end
context 'rescue' do
it_behaves_like 'common behavior', 'rescue'
it 'accepts the modifier form' do
inspect_source(cop, 'test rescue nil')
expect(cop.messages).to be_empty
end
end
context 'ensure' do
it_behaves_like 'common behavior', 'ensure'
end
describe 'excluded file' do
let(:config) do
RuboCop::Config.new('Style/RescueEnsureAlignment' =>
{ 'Enabled' => true,
'Exclude' => ['**/**'] })
end
subject(:cop) { described_class.new(config) }
it 'processes excluded files with issue' do
inspect_source_file(cop, ['begin',
' foo',
'rescue',
' bar',
'end'])
expect(cop.messages).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/rescue_modifier_spec.rb 0000664 0000000 0000000 00000016322 13070542236 0026170 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::RescueModifier do
let(:config) do
RuboCop::Config.new('Style/IndentationWidth' => {
'Width' => 2
})
end
subject(:cop) { described_class.new(config) }
it 'registers an offense for modifier rescue' do
inspect_source(cop, 'method rescue handle')
expect(cop.messages)
.to eq(['Avoid using `rescue` in its modifier form.'])
expect(cop.highlights).to eq(['method rescue handle'])
end
it 'registers an offense for modifier rescue around parallel assignment' do
inspect_source(cop, 'a, b = 1, 2 rescue nil')
expect(cop.messages)
.to eq(['Avoid using `rescue` in its modifier form.'])
end
it 'handles more complex expression with modifier rescue' do
inspect_source(cop, 'method1 or method2 rescue handle')
expect(cop.messages)
.to eq(['Avoid using `rescue` in its modifier form.'])
expect(cop.highlights).to eq(['method1 or method2 rescue handle'])
end
it 'handles modifier rescue in normal rescue' do
inspect_source(cop,
['begin',
' test rescue modifier_handle',
'rescue',
' normal_handle',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line).to eq(2)
expect(cop.highlights).to eq(['test rescue modifier_handle'])
end
it 'handles modifier rescue in a method' do
inspect_source(cop,
['def a_method',
' test rescue nil',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line).to eq(2)
end
it 'does not register an offense for normal rescue' do
inspect_source(cop,
['begin',
' test',
'rescue',
' handle',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense for normal rescue with ensure' do
inspect_source(cop,
['begin',
' test',
'rescue',
' handle',
'ensure',
' cleanup',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense for nested normal rescue' do
inspect_source(cop,
['begin',
' begin',
' test',
' rescue',
' handle_inner',
' end',
'rescue',
' handle_outer',
'end'])
expect(cop.offenses).to be_empty
end
context 'when an instance method has implicit begin' do
it 'accepts normal rescue' do
inspect_source(cop,
['def some_method',
' test',
'rescue',
' handle',
'end'])
expect(cop.offenses).to be_empty
end
it 'handles modifier rescue in body of implicit begin' do
inspect_source(cop,
['def some_method',
' test rescue modifier_handle',
'rescue',
' normal_handle',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line).to eq(2)
expect(cop.highlights).to eq(['test rescue modifier_handle'])
end
end
context 'when a singleton method has implicit begin' do
it 'accepts normal rescue' do
inspect_source(cop,
['def self.some_method',
' test',
'rescue',
' handle',
'end'])
expect(cop.offenses).to be_empty
end
it 'handles modifier rescue in body of implicit begin' do
inspect_source(cop,
['def self.some_method',
' test rescue modifier_handle',
'rescue',
' normal_handle',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line).to eq(2)
expect(cop.highlights).to eq(['test rescue modifier_handle'])
end
end
context 'autocorrect' do
it 'corrects basic rescue modifier' do
new_source = autocorrect_source(cop, 'foo rescue bar')
expect(new_source).to eq(['begin',
' foo',
'rescue',
' bar',
'end'].join("\n"))
end
it 'corrects complex rescue modifier' do
new_source = autocorrect_source(cop, 'foo || bar rescue bar')
expect(new_source).to eq(['begin',
' foo || bar',
'rescue',
' bar',
'end'].join("\n"))
end
it 'corrects rescue modifier nested inside of def' do
source = ['def foo',
' test rescue modifier_handle',
'end'].join("\n")
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['def foo',
' begin',
' test',
' rescue',
' modifier_handle',
' end',
'end'].join("\n"))
end
it 'corrects nested rescue modifier' do
source = ['begin',
' test rescue modifier_handle',
'rescue',
' normal_handle',
'end'].join("\n")
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(['begin',
' begin',
' test',
' rescue',
' modifier_handle',
' end',
'rescue',
' normal_handle',
'end'].join("\n"))
end
it 'corrects doubled rescue modifiers' do
source = 'blah rescue 1 rescue 2'
new_source = autocorrect_source(cop, source)
# Another round of autocorrection is needed
new_source = autocorrect_source(described_class.new(config), new_source)
expect(new_source).to eq(['begin',
' begin',
' blah',
' rescue',
' 1',
' end',
'rescue',
' 2',
'end'].join("\n"))
end
end
describe 'excluded file' do
let(:config) do
RuboCop::Config.new('Style/RescueModifier' =>
{ 'Enabled' => true,
'Exclude' => ['**/**'] })
end
subject(:cop) { described_class.new(config) }
it 'processes excluded files with issue' do
inspect_source_file(cop, 'foo rescue bar')
expect(cop.messages).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/safe_navigation_spec.rb 0000664 0000000 0000000 00000100440 13070542236 0026154 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SafeNavigation, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'ConvertCodeThatCanStartToReturnNil' => false } }
context 'target_ruby_version > 2.3', :ruby23 do
it 'allows calls to methods not safeguarded by respond_to' do
inspect_source(cop, 'foo.bar')
expect(cop.offenses).to be_empty
end
it 'allows calls using safe navigation' do
inspect_source(cop, 'foo&.bar')
expect(cop.offenses).to be_empty
end
it 'allows calls on nil' do
inspect_source(cop, 'nil&.bar')
expect(cop.offenses).to be_empty
end
it 'allows method calls that nil responds to safe guarded by ' \
'an object check' do
inspect_source(cop, 'foo.to_i if foo')
expect(cop.offenses).to be_empty
end
it 'allows method calls that do not get called using . safe guarded by ' \
'an object check' do
inspect_source(cop, 'foo + bar if foo')
expect(cop.offenses).to be_empty
end
it 'allows object checks in the condition of an elsif statement ' \
'and a method call on that object in the body' do
inspect_source(cop, ['if foo',
' something',
'elsif bar',
' bar.baz',
'end'])
expect(cop.offenses).to be_empty
end
shared_examples 'all variable types' do |variable|
context 'modifier if' do
it 'registers an offense for a method call on an accessor ' \
'safeguarded by a check for the accessed variable' do
inspect_source(cop, "#{variable}[1].bar if #{variable}[1]")
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for a method call safeguarded with a check ' \
'for the object' do
inspect_source(cop, "#{variable}.bar if #{variable}")
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for a method call with params safeguarded ' \
'with a check for the object' do
inspect_source(cop, "#{variable}.bar(baz) if #{variable}")
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for a method call with a block safeguarded ' \
'with a check for the object' do
inspect_source(cop, "#{variable}.bar { |e| e.qux } if #{variable}")
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for a method call with params and a block ' \
'safeguarded with a check for the object' do
inspect_source(cop,
"#{variable}.bar(baz) { |e| e.qux } if #{variable}")
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for a method call safeguarded with a ' \
'negative check for the object' do
inspect_source(cop, "#{variable}.bar unless !#{variable}")
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for a method call with params safeguarded ' \
'with a negative check for the object' do
inspect_source(cop, "#{variable}.bar(baz) unless !#{variable}")
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for a method call with a block safeguarded ' \
'with a negative check for the object' do
inspect_source(cop,
"#{variable}.bar { |e| e.qux } unless !#{variable}")
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for a method call with params and a block ' \
'safeguarded with a negative check for the object' do
source = "#{variable}.bar(baz) { |e| e.qux } unless !#{variable}"
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for a method call safeguarded with a nil ' \
'check for the object' do
inspect_source(cop, "#{variable}.bar unless #{variable}.nil?")
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for a method call with params safeguarded ' \
'with a nil check for the object' do
inspect_source(cop, "#{variable}.bar(baz) unless #{variable}.nil?")
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for a method call with a block safeguarded ' \
'with a nil check for the object' do
source = "#{variable}.bar { |e| e.qux } unless #{variable}.nil?"
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for a method call with params and a block ' \
'safeguarded with a nil check for the object' do
source = "#{variable}.bar(baz) { |e| e.qux } unless #{variable}.nil?"
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for a method call safeguarded with a ' \
'negative nil check for the object' do
inspect_source(cop, "#{variable}.bar if !#{variable}.nil?")
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for a method call with params safeguarded ' \
'with a negative nil check for the object' do
inspect_source(cop, "#{variable}.bar(baz) if !#{variable}.nil?")
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for a method call with a block safeguarded ' \
'with a negative nil check for the object' do
source = "#{variable}.bar { |e| e.qux } if !#{variable}.nil?"
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for a method call with params and a block ' \
'safeguarded with a negative nil check for the object' do
source = "#{variable}.bar(baz) { |e| e.qux } if !#{variable}.nil?"
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
end
context 'if expression' do
it 'registers an offense for a single method call inside of a check ' \
'for the object' do
inspect_source(cop, ["if #{variable}",
" #{variable}.bar",
'end'])
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for a single method call inside of a ' \
'non-nil check for the object' do
inspect_source(cop, ["if !#{variable}.nil?",
" #{variable}.bar",
'end'])
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for a single method call inside of an ' \
'unless nil check for the object' do
inspect_source(cop, ["unless #{variable}.nil?",
" #{variable}.bar",
'end'])
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for a single method call inside of an ' \
'unless negative check for the object' do
inspect_source(cop, ["unless !#{variable}",
" #{variable}.bar",
'end'])
expect(cop.messages).to eq([described_class::MSG])
end
it 'accepts a single method call inside of a check for the object ' \
'with an else' do
inspect_source(cop, ["if #{variable}",
" #{variable}.bar",
'else',
' something',
'end'])
expect(cop.offenses).to be_empty
end
context 'ternary expression' do
it 'accepts ternary expression' do
source = "!#{variable}.nil? ? #{variable}.bar : something"
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
context 'object check before method call' do
context 'ConvertCodeThatCanStartToReturnNil true' do
let(:cop_config) { { 'ConvertCodeThatCanStartToReturnNil' => true } }
it 'registers an offense for a non-nil object check followed by a ' \
'method call' do
inspect_source(cop, "!#{variable}.nil? && #{variable}.bar")
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for a non-nil object check followed by a ' \
'method call with params' do
inspect_source(cop, "!#{variable}.nil? && #{variable}.bar(baz)")
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for a non-nil object check followed by a ' \
'method call with a block' do
source = "!#{variable}.nil? && #{variable}.bar { |e| e.qux }"
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for a non-nil object check followed by a ' \
'method call with params and a block' do
source = "!#{variable}.nil? && #{variable}.bar(baz) { |e| e.qux }"
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for an object check followed by a ' \
'method call' do
inspect_source(cop, "#{variable} && #{variable}.bar")
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for an object check followed by a ' \
'method call with params' do
inspect_source(cop, "#{variable} && #{variable}.bar(baz)")
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for an object check followed by a ' \
'method call with a block' do
inspect_source(cop, "#{variable} && #{variable}.bar { |e| e.qux }")
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for an object check followed by a ' \
'method call with params and a block' do
source = "#{variable} && #{variable}.bar(baz) { |e| e.qux }"
inspect_source(cop, source)
expect(cop.messages).to eq([described_class::MSG])
end
it 'registers an offense for a check for the object followed by a ' \
'method call in the condition for an if expression' do
inspect_source(cop, ["if #{variable} && #{variable}.bar",
' something',
'end'])
expect(cop.messages).to eq([described_class::MSG])
end
end
context 'ConvertCodeThatCanStartToReturnNil false' do
it 'registers an offense for a non-nil object check followed by a ' \
'method call' do
inspect_source(cop, "!#{variable}.nil? && #{variable}.bar")
expect(cop.offenses).to be_empty
end
it 'registers an offense for a non-nil object check followed by a ' \
'method call with params' do
inspect_source(cop, "!#{variable}.nil? && #{variable}.bar(baz)")
expect(cop.offenses).to be_empty
end
it 'registers an offense for a non-nil object check followed by a ' \
'method call with a block' do
source = "!#{variable}.nil? && #{variable}.bar { |e| e.qux }"
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'registers an offense for a non-nil object check followed by a ' \
'method call with params and a block' do
source = "!#{variable}.nil? && #{variable}.bar(baz) { |e| e.qux }"
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'registers an offense for an object check followed by a ' \
'method call' do
inspect_source(cop, "#{variable} && #{variable}.bar")
expect(cop.offenses).to be_empty
end
it 'registers an offense for an object check followed by a ' \
'method call with params' do
inspect_source(cop, "#{variable} && #{variable}.bar(baz)")
expect(cop.offenses).to be_empty
end
it 'registers an offense for an object check followed by a ' \
'method call with a block' do
inspect_source(cop, "#{variable} && #{variable}.bar { |e| e.qux }")
expect(cop.offenses).to be_empty
end
it 'registers an offense for an object check followed by a ' \
'method call with params and a block' do
source = "#{variable} && #{variable}.bar(baz) { |e| e.qux }"
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'registers an offense for a check for the object followed by a ' \
'method call in the condition for an if expression' do
inspect_source(cop, ["if #{variable} && #{variable}.bar",
' something',
'end'])
expect(cop.offenses).to be_empty
end
end
it 'allows a nil object check followed by a method call' do
inspect_source(cop, "#{variable}.nil? || #{variable}.bar")
expect(cop.offenses).to be_empty
end
it 'allows a nil object check followed by a method call with params' do
inspect_source(cop, "#{variable}.nil? || #{variable}.bar(baz)")
expect(cop.offenses).to be_empty
end
it 'allows a nil object check followed by a method call with a block' do
source = "#{variable}.nil? || #{variable}.bar { |e| e.qux }"
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows a nil object check followed by a method call with params ' \
'and a block' do
source = "#{variable}.nil? || #{variable}.bar(baz) { |e| e.qux }"
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'allows a non object check followed by a method call' do
inspect_source(cop, "!#{variable} || #{variable}.bar")
expect(cop.offenses).to be_empty
end
it 'allows a non object check followed by a method call with params' do
inspect_source(cop, "!#{variable} || #{variable}.bar(baz)")
expect(cop.offenses).to be_empty
end
it 'allows a non object check followed by a method call with a block' do
inspect_source(cop, "!#{variable} || #{variable}.bar { |e| e.qux }")
expect(cop.offenses).to be_empty
end
it 'allows a non object check followed by a method call with params ' \
'and a block' do
source = "!#{variable} || #{variable}.bar(baz) { |e| e.qux }"
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
end
end
it_behaves_like('all variable types', 'foo')
it_behaves_like('all variable types', 'FOO')
it_behaves_like('all variable types', 'FOO::BAR')
it_behaves_like('all variable types', '@foo')
it_behaves_like('all variable types', '@@foo')
it_behaves_like('all variable types', '$FOO')
context 'respond_to?' do
it 'allows method calls safeguarded by a respond_to check' do
inspect_source(cop, 'foo.bar if foo.respond_to?(:bar)')
expect(cop.offenses).to be_empty
end
it 'allows method calls safeguarded by a respond_to check to a ' \
'different method' do
inspect_source(cop, 'foo.bar if foo.respond_to?(:foobar)')
expect(cop.offenses).to be_empty
end
it 'allows method calls safeguarded by a respond_to check on a' \
'different variable but the same method' do
inspect_source(cop, 'foo.bar if baz.respond_to?(:bar)')
expect(cop.offenses).to be_empty
end
it 'allows method calls safeguarded by a respond_to check on a' \
'different variable and method' do
inspect_source(cop, 'foo.bar if baz.respond_to?(:foo)')
expect(cop.offenses).to be_empty
end
it 'allows enumerable accessor method calls safeguarded by ' \
'a respond_to check' do
inspect_source(cop, 'foo[0] if foo.respond_to?(:[])')
expect(cop.offenses).to be_empty
end
end
context 'auto-correct' do
shared_examples 'all variable types' do |variable|
context 'modifier if' do
it 'corrects a method call safeguarded with a check for the object' do
source = "#{variable}.bar if #{variable}"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar")
end
it 'corrects a method call with params safeguarded with a check ' \
'for the object' do
source = "#{variable}.bar(baz) if #{variable}"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar(baz)")
end
it 'corrects a method call with a block safeguarded with a check ' \
'for the object' do
source = "#{variable}.bar { |e| e.qux } if #{variable}"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar { |e| e.qux }")
end
it 'corrects a method call with params and a block safeguarded ' \
'with a check for the object' do
source = "#{variable}.bar(baz) { |e| e.qux } if #{variable}"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar(baz) { |e| e.qux }")
end
it 'corrects a method call safeguarded with a negative check for ' \
'the object' do
source = "#{variable}.bar unless !#{variable}"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar")
end
it 'corrects a method call with params safeguarded with a ' \
'negative check for the object' do
source = "#{variable}.bar(baz) unless !#{variable}"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar(baz)")
end
it 'corrects a method call with a block safeguarded with a ' \
'negative check for the object' do
source = "#{variable}.bar { |e| e.qux } unless !#{variable}"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar { |e| e.qux }")
end
it 'corrects a method call with params and a block safeguarded ' \
'with a negative check for the object' do
source = "#{variable}.bar(baz) { |e| e.qux } unless !#{variable}"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar(baz) { |e| e.qux }")
end
it 'corrects a method call safeguarded with a nil check for the ' \
'object' do
source = "#{variable}.bar unless #{variable}.nil?"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar")
end
it 'corrects a method call with params safeguarded with a nil ' \
'check for the object' do
source = "#{variable}.bar(baz) unless #{variable}.nil?"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar(baz)")
end
it 'corrects a method call with a block safeguarded with a nil ' \
'check for the object' do
source = "#{variable}.bar { |e| e.qux } unless #{variable}.nil?"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar { |e| e.qux }")
end
it 'corrects a method call with params and a block safeguarded ' \
'with a nil check for the object' do
source =
"#{variable}.bar(baz) { |e| e.qux } unless #{variable}.nil?"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar(baz) { |e| e.qux }")
end
it 'corrects a method call safeguarded with a negative nil check ' \
'for the object' do
source = "#{variable}.bar if !#{variable}.nil?"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar")
end
it 'corrects a method call with params safeguarded with a ' \
'negative nil check for the object' do
source = "#{variable}.bar(baz) if !#{variable}.nil?"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar(baz)")
end
it 'corrects a method call with a block safeguarded with a ' \
'negative nil check for the object' do
source = "#{variable}.bar { |e| e.qux } if !#{variable}.nil?"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar { |e| e.qux }")
end
it 'corrects a method call with params and a block safeguarded ' \
'with a negative nil check for the object' do
source = "#{variable}.bar(baz) { |e| e.qux } if !#{variable}.nil?"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar(baz) { |e| e.qux }")
end
it 'corrects a method call on an accessor safeguarded by a check ' \
'for the accessed variable' do
source = "#{variable}[1].bar if #{variable}[1]"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}[1]&.bar")
end
end
context 'if expression' do
it 'corrects a single method call inside of a check for the object' do
new_source = autocorrect_source(cop, ["if #{variable}",
" #{variable}.bar",
'end'])
expect(new_source).to eq("#{variable}&.bar")
end
it 'corrects a single method call with params inside of a check ' \
'for the object' do
new_source = autocorrect_source(cop, ["if #{variable}",
" #{variable}.bar(baz)",
'end'])
expect(new_source).to eq("#{variable}&.bar(baz)")
end
it 'corrects a single method call with a block inside of a check ' \
'for the object' do
source = ["if #{variable}",
" #{variable}.bar { |e| e.qux }",
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar { |e| e.qux }")
end
it 'corrects a single method call with params and a block inside ' \
'of a check for the object' do
source = ["if #{variable}",
" #{variable}.bar(baz) { |e| e.qux }",
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar(baz) { |e| e.qux }")
end
it 'corrects a single method call inside of a non-nil check for ' \
'the object' do
new_source = autocorrect_source(cop, ["if !#{variable}.nil?",
" #{variable}.bar",
'end'])
expect(new_source).to eq("#{variable}&.bar")
end
it 'corrects a single method call with params inside of a non-nil ' \
'check for the object' do
new_source = autocorrect_source(cop, ["if !#{variable}.nil?",
" #{variable}.bar(baz)",
'end'])
expect(new_source).to eq("#{variable}&.bar(baz)")
end
it 'corrects a single method call with a block inside of a non-nil ' \
'check for the object' do
source = ["if !#{variable}.nil?",
" #{variable}.bar { |e| e.qux }",
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar { |e| e.qux }")
end
it 'corrects a single method call with params and a block inside ' \
'of a non-nil check for the object' do
source = ["if !#{variable}.nil?",
" #{variable}.bar(baz) { |e| e.qux }",
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar(baz) { |e| e.qux }")
end
it 'corrects a single method call inside of an unless nil check ' \
'for the object' do
new_source = autocorrect_source(cop, ["unless #{variable}.nil?",
" #{variable}.bar",
'end'])
expect(new_source).to eq("#{variable}&.bar")
end
it 'corrects a single method call with params inside of an unless ' \
'nil check for the object' do
new_source = autocorrect_source(cop, ["unless #{variable}.nil?",
" #{variable}.bar(baz)",
'end'])
expect(new_source).to eq("#{variable}&.bar(baz)")
end
it 'corrects a single method call with a block inside of an unless ' \
'nil check for the object' do
source = ["unless #{variable}.nil?",
" #{variable}.bar { |e| e.qux }",
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar { |e| e.qux }")
end
it 'corrects a single method call with params and a block inside ' \
'of an unless nil check for the object' do
source = ["unless #{variable}.nil?",
" #{variable}.bar(baz) { |e| e.qux }",
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar(baz) { |e| e.qux }")
end
it 'corrects a single method call inside of an unless negative ' \
'check for the object' do
new_source = autocorrect_source(cop, ["unless !#{variable}",
" #{variable}.bar",
'end'])
expect(new_source).to eq("#{variable}&.bar")
end
it 'corrects a single method call with params inside of an unless ' \
'negative check for the object' do
new_source = autocorrect_source(cop, ["unless !#{variable}",
" #{variable}.bar(baz)",
'end'])
expect(new_source).to eq("#{variable}&.bar(baz)")
end
it 'corrects a single method call with a block inside of an unless ' \
'negative check for the object' do
source = ["unless !#{variable}",
" #{variable}.bar { |e| e.qux }",
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar { |e| e.qux }")
end
it 'corrects a single method call with params and a block inside ' \
'of an unless negative check for the object' do
source = ["unless !#{variable}",
" #{variable}.bar(baz) { |e| e.qux }",
'end']
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar(baz) { |e| e.qux }")
end
end
context 'object check before method call' do
context 'ConvertCodeThatCanStartToReturnNil true' do
let(:cop_config) do
{ 'ConvertCodeThatCanStartToReturnNil' => true }
end
it 'corrects an object check followed by a method call' do
source = "#{variable} && #{variable}.bar"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar")
end
it 'corrects an object check followed by a method call ' \
'with params' do
source = "#{variable} && #{variable}.bar(baz)"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar(baz)")
end
it 'corrects an object check followed by a method call with ' \
'a block' do
source = "#{variable} && #{variable}.bar { |e| e.qux }"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar { |e| e.qux }")
end
it 'corrects an object check followed by a method call with ' \
'params and a block' do
source = "#{variable} && #{variable}.bar(baz) { |e| e.qux }"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar(baz) { |e| e.qux }")
end
it 'corrects a non-nil object check followed by a method call' do
source = "!#{variable}.nil? && #{variable}.bar"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar")
end
it 'corrects a non-nil object check followed by a method call ' \
'with params' do
source = "!#{variable}.nil? && #{variable}.bar(baz)"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar(baz)")
end
it 'corrects a non-nil object check followed by a method call ' \
'with a block' do
source = "!#{variable}.nil? && #{variable}.bar { |e| e.qux }"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar { |e| e.qux }")
end
it 'corrects a non-nil object check followed by a method call ' \
'with params and a block' do
source = "!#{variable}.nil? && #{variable}.bar(baz) { |e| e.qux }"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar(baz) { |e| e.qux }")
end
it 'corrects an object check followed by a method call and ' \
'another check' do
source = "#{variable} && #{variable}.bar && something"
new_source = autocorrect_source(cop, source)
expect(new_source).to eq("#{variable}&.bar && something")
end
end
end
end
it_behaves_like('all variable types', 'foo')
it_behaves_like('all variable types', 'FOO')
it_behaves_like('all variable types', 'FOO::BAR')
it_behaves_like('all variable types', '@foo')
it_behaves_like('all variable types', '@@foo')
it_behaves_like('all variable types', '$FOO')
end
end
context 'target_ruby_version < 2.3', :ruby19 do
it 'allows a method call safeguarded by a check for the variable' do
inspect_source(cop, 'foo.bar if foo')
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/self_assignment_spec.rb 0000664 0000000 0000000 00000003071 13070542236 0026202 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SelfAssignment do
subject(:cop) { described_class.new }
%i[+ - * ** / | &].product(['x', '@x', '@@x']).each do |op, var|
it "registers an offense for non-shorthand assignment #{op} and #{var}" do
inspect_source(cop,
"#{var} = #{var} #{op} y")
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(["Use self-assignment shorthand `#{op}=`."])
end
it "accepts shorthand assignment for #{op} and #{var}" do
inspect_source(cop,
"#{var} #{op}= y")
expect(cop.offenses).to be_empty
end
it "auto-corrects a non-shorthand assignment #{op} and #{var}" do
new_source = autocorrect_source(cop, "#{var} = #{var} #{op} y")
expect(new_source).to eq("#{var} #{op}= y")
end
end
['||', '&&'].product(['x', '@x', '@@x']).each do |op, var|
it "registers an offense for non-shorthand assignment #{op} and #{var}" do
inspect_source(cop,
"#{var} = #{var} #{op} y")
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(["Use self-assignment shorthand `#{op}=`."])
end
it "accepts shorthand assignment for #{op} and #{var}" do
inspect_source(cop,
"#{var} #{op}= y")
expect(cop.offenses).to be_empty
end
it "auto-corrects a non-shorthand assignment #{op} and #{var}" do
new_source = autocorrect_source(cop, "#{var} = #{var} #{op} y")
expect(new_source).to eq("#{var} #{op}= y")
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/semicolon_spec.rb 0000664 0000000 0000000 00000007274 13070542236 0025022 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::Semicolon, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'AllowAsExpressionSeparator' => false } }
it 'registers an offense for a single expression' do
inspect_source(cop,
'puts "this is a test";')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for several expressions' do
inspect_source(cop,
'puts "this is a test"; puts "So is this"')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for one line method with two statements' do
inspect_source(cop,
'def foo(a) x(1); y(2); z(3); end')
expect(cop.offenses.size).to eq(1)
end
it 'accepts semicolon before end if so configured' do
inspect_source(cop,
'def foo(a) z(3); end')
expect(cop.offenses).to be_empty
end
it 'accepts semicolon after params if so configured' do
inspect_source(cop,
'def foo(a); z(3) end')
expect(cop.offenses).to be_empty
end
it 'accepts one line method definitions' do
inspect_source(cop,
['def foo1; x(3) end',
'def initialize(*_); end',
'def foo2() x(3); end',
'def foo3; x(3); end'])
expect(cop.offenses).to be_empty
end
it 'accepts one line empty class definitions' do
inspect_source(cop,
['# Prefer a single-line format for class ...',
'class Foo < Exception; end',
'',
'class Bar; end'])
expect(cop.offenses).to be_empty
end
it 'accepts one line empty method definitions' do
inspect_source(cop,
['# One exception to the rule are empty-body methods',
'def no_op; end',
'',
'def foo; end'])
expect(cop.offenses).to be_empty
end
it 'accepts one line empty module definitions' do
inspect_source(cop,
'module Foo; end')
expect(cop.offenses).to be_empty
end
it 'registers an offense for semicolon at the end no matter what' do
inspect_source(cop,
'module Foo; end;')
expect(cop.offenses.size).to eq(1)
end
it 'accept semicolons inside strings' do
inspect_source(cop,
['string = ";',
'multi-line string"'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for a semicolon at the beginning of a line' do
inspect_source(cop, '; puts 1')
expect(cop.offenses.size).to eq(1)
end
it 'auto-corrects semicolons when syntactically possible' do
corrected =
autocorrect_source(cop,
['module Foo; end;',
'puts "this is a test";',
'puts "this is a test"; puts "So is this"',
'def foo(a) x(1); y(2); z(3); end',
';puts 1'])
expect(corrected)
.to eq(['module Foo; end',
'puts "this is a test"',
'puts "this is a test"; puts "So is this"',
'def foo(a) x(1); y(2); z(3); end',
'puts 1'].join("\n"))
end
context 'when AllowAsExpressionSeparator is true' do
let(:cop_config) { { 'AllowAsExpressionSeparator' => true } }
it 'accepts several expressions' do
inspect_source(cop,
'puts "this is a test"; puts "So is this"')
expect(cop.offenses).to be_empty
end
it 'accepts one line method with two statements' do
inspect_source(cop,
'def foo(a) x(1); y(2); z(3); end')
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/send_spec.rb 0000664 0000000 0000000 00000004424 13070542236 0023755 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::Send do
subject(:cop) { described_class.new }
context 'with send' do
context 'and with a receiver' do
it 'registers an offense for an invocation with args' do
inspect_source(cop, 'Object.send(:inspect)')
expect(cop.offenses.size).to eq(1)
end
it 'does not register an offense for an invocation without args' do
inspect_source(cop, 'Object.send')
expect(cop.offenses).to be_empty
end
end
context 'and without a receiver' do
it 'registers an offense for an invocation with args' do
inspect_source(cop, 'send(:inspect)')
expect(cop.offenses.size).to eq(1)
end
it 'does not register an offense for an invocation without args' do
inspect_source(cop, 'send')
expect(cop.offenses).to be_empty
end
end
end
context 'with __send__' do
after { expect(cop.offenses).to be_empty }
context 'and with a receiver' do
it 'does not register an offense for an invocation with args' do
inspect_source(cop, 'Object.__send__(:inspect)')
end
it 'does not register an offense for an invocation without args' do
inspect_source(cop, 'Object.__send__')
end
end
context 'and without a receiver' do
it 'does not register an offense for an invocation with args' do
inspect_source(cop, '__send__(:inspect)')
end
it 'does not register an offense for an invocation without args' do
inspect_source(cop, '__send__')
end
end
end
context 'with public_send' do
after { expect(cop.offenses).to be_empty }
context 'and with a receiver' do
it 'does not register an offense for an invocation with args' do
inspect_source(cop, 'Object.public_send(:inspect)')
end
it 'does not register an offense for an invocation without args' do
inspect_source(cop, 'Object.public_send')
end
end
context 'and without a receiver' do
it 'does not register an offense for an invocation with args' do
inspect_source(cop, 'public_send(:inspect)')
end
it 'does not register an offense for an invocation without args' do
inspect_source(cop, 'public_send')
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/signal_exception_spec.rb 0000664 0000000 0000000 00000030471 13070542236 0026360 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SignalException, :config do
subject(:cop) { described_class.new(config) }
context 'when enforced style is `semantic`' do
let(:cop_config) { { 'EnforcedStyle' => 'semantic' } }
it 'registers an offense for raise in begin section' do
inspect_source(cop,
['begin',
' raise',
'rescue Exception',
' #do nothing',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `fail` instead of `raise` to signal exceptions.'])
end
it 'registers an offense for raise in def body' do
inspect_source(cop,
['def test',
' raise',
'rescue Exception',
' #do nothing',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `fail` instead of `raise` to signal exceptions.'])
end
it 'registers an offense for fail in rescue section' do
inspect_source(cop,
['begin',
' fail',
'rescue Exception',
' fail',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `raise` instead of `fail` to rethrow exceptions.'])
end
it 'accepts raise in rescue section' do
inspect_source(cop,
['begin',
' fail',
'rescue Exception',
' raise RuntimeError',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts raise in def with multiple rescues' do
inspect_source(cop,
['def test',
' fail',
'rescue StandardError',
' # handle error',
'rescue Exception',
' raise',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for fail in def rescue section' do
inspect_source(cop,
['def test',
' fail',
'rescue Exception',
' fail',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `raise` instead of `fail` to rethrow exceptions.'])
end
it 'registers an offense for fail in second rescue' do
inspect_source(cop,
['def test',
' fail',
'rescue StandardError',
' # handle error',
'rescue Exception',
' fail',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers only offense for one raise that should be fail' do
# This is a special case that has caused double reporting.
inspect_source(cop,
['map do',
" raise 'I'",
'end.flatten.compact'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `fail` instead of `raise` to signal exceptions.'])
end
it 'accepts raise in def rescue section' do
inspect_source(cop,
['def test',
' fail',
'rescue Exception',
' raise',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts `raise` and `fail` with explicit receiver' do
inspect_source(cop,
['def test',
' test.raise',
'rescue Exception',
' test.fail',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for `raise` and `fail` with `Kernel` as ' \
'explicit receiver' do
inspect_source(cop,
['def test',
' Kernel.raise',
'rescue Exception',
' Kernel.fail',
'end'])
expect(cop.offenses.size).to eq(2)
expect(cop.messages)
.to eq(['Use `fail` instead of `raise` to signal exceptions.',
'Use `raise` instead of `fail` to rethrow exceptions.'])
end
it 'registers an offense for raise not in a begin/rescue/end' do
inspect_source(cop,
["case cop_config['EnforcedStyle']",
"when 'single_quotes' then true",
"when 'double_quotes' then false",
"else raise 'Unknown StringLiterals style'",
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Use `fail` instead of `raise` to signal exceptions.'])
end
it 'registers one offense for each raise' do
inspect_source(cop,
['cop.stub(:on_def) { raise RuntimeError }',
'cop.stub(:on_def) { raise RuntimeError }'])
expect(cop.offenses.size).to eq(2)
expect(cop.messages)
.to eq(['Use `fail` instead of `raise` to signal exceptions.'] * 2)
end
it 'is not confused by nested begin/rescue' do
inspect_source(cop,
['begin',
' raise',
' begin',
' raise',
' rescue',
' fail',
' end',
'rescue Exception',
' #do nothing',
'end'])
expect(cop.offenses.size).to eq(3)
expect(cop.messages)
.to eq(['Use `fail` instead of `raise` to signal exceptions.'] * 2 +
['Use `raise` instead of `fail` to rethrow exceptions.'])
end
it 'auto-corrects raise to fail when appropriate' do
new_source = autocorrect_source(cop,
['begin',
' raise',
'rescue Exception',
' raise',
'end'])
expect(new_source).to eq(['begin',
' fail',
'rescue Exception',
' raise',
'end'].join("\n"))
end
it 'auto-corrects fail to raise when appropriate' do
new_source = autocorrect_source(cop,
['begin',
' fail',
'rescue Exception',
' fail',
'end'])
expect(new_source).to eq(['begin',
' fail',
'rescue Exception',
' raise',
'end'].join("\n"))
end
end
context 'when enforced style is `raise`' do
let(:cop_config) { { 'EnforcedStyle' => 'only_raise' } }
it 'registers an offense for fail in begin section' do
inspect_source(cop,
['begin',
' fail',
'rescue Exception',
' #do nothing',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Always use `raise` to signal exceptions.'])
end
it 'registers an offense for fail in def body' do
inspect_source(cop,
['def test',
' fail',
'rescue Exception',
' #do nothing',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Always use `raise` to signal exceptions.'])
end
it 'registers an offense for fail in rescue section' do
inspect_source(cop,
['begin',
' raise',
'rescue Exception',
' fail',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Always use `raise` to signal exceptions.'])
end
it 'accepts `fail` if a custom `fail` instance method is defined' do
inspect_source(cop,
['class A',
' def fail(arg)',
' end',
' def other_method',
' fail "message"',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts `fail` if a custom `fail` singleton method is defined' do
inspect_source(cop,
['class A',
' def self.fail(arg)',
' end',
' def self.other_method',
' fail "message"',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts `fail` with explicit receiver' do
inspect_source(cop, 'test.fail')
expect(cop.offenses).to be_empty
end
it 'registers an offense for `fail` with `Kernel` as explicit receiver' do
inspect_source(cop, 'Kernel.fail')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Always use `raise` to signal exceptions.'])
end
it 'auto-corrects fail to raise always' do
new_source = autocorrect_source(cop,
['begin',
' fail',
'rescue Exception',
' fail',
'end'])
expect(new_source).to eq(['begin',
' raise',
'rescue Exception',
' raise',
'end'].join("\n"))
end
end
context 'when enforced style is `fail`' do
let(:cop_config) { { 'EnforcedStyle' => 'only_fail' } }
it 'registers an offense for raise in begin section' do
inspect_source(cop,
['begin',
' raise',
'rescue Exception',
' #do nothing',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Always use `fail` to signal exceptions.'])
end
it 'registers an offense for raise in def body' do
inspect_source(cop,
['def test',
' raise',
'rescue Exception',
' #do nothing',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Always use `fail` to signal exceptions.'])
end
it 'registers an offense for raise in rescue section' do
inspect_source(cop,
['begin',
' fail',
'rescue Exception',
' raise',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Always use `fail` to signal exceptions.'])
end
it 'accepts `raise` with explicit receiver' do
inspect_source(cop, 'test.raise')
expect(cop.offenses).to be_empty
end
it 'registers an offense for `raise` with `Kernel` as explicit receiver' do
inspect_source(cop, 'Kernel.raise')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Always use `fail` to signal exceptions.'])
end
it 'auto-corrects raise to fail always' do
new_source = autocorrect_source(cop,
['begin',
' raise',
'rescue Exception',
' raise',
'end'])
expect(new_source).to eq(['begin',
' fail',
'rescue Exception',
' fail',
'end'].join("\n"))
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/single_line_block_params_spec.rb 0000664 0000000 0000000 00000005637 13070542236 0030040 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SingleLineBlockParams, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) do
{ 'Methods' =>
[{ 'reduce' => %w[a e] },
{ 'test' => %w[x y] }] }
end
it 'finds wrong argument names in calls with different syntax' do
inspect_source(cop,
['def m',
' [0, 1].reduce { |c, d| c + d }',
' [0, 1].reduce{ |c, d| c + d }',
' [0, 1].reduce(5) { |c, d| c + d }',
' [0, 1].reduce(5){ |c, d| c + d }',
' [0, 1].reduce (5) { |c, d| c + d }',
' [0, 1].reduce(5) { |c, d| c + d }',
' ala.test { |x, z| bala }',
'end'])
expect(cop.offenses.size).to eq(7)
expect(cop.offenses.map(&:line).sort).to eq((2..8).to_a)
expect(cop.messages.first)
.to eq('Name `reduce` block params `|a, e|`.')
end
it 'allows calls with proper argument names' do
inspect_source(cop,
['def m',
' [0, 1].reduce { |a, e| a + e }',
' [0, 1].reduce{ |a, e| a + e }',
' [0, 1].reduce(5) { |a, e| a + e }',
' [0, 1].reduce(5){ |a, e| a + e }',
' [0, 1].reduce (5) { |a, e| a + e }',
' [0, 1].reduce(5) { |a, e| a + e }',
' ala.test { |x, y| bala }',
'end'])
expect(cop.offenses).to be_empty
end
it 'allows an unused parameter to have a leading underscore' do
inspect_source(cop,
'File.foreach(filename).reduce(0) { |a, _e| a + 1 }')
expect(cop.offenses).to be_empty
end
it 'finds incorrectly named parameters with leading underscores' do
inspect_source(cop,
'File.foreach(filename).reduce(0) { |_x, _y| }')
expect(cop.messages).to eq(['Name `reduce` block params `|a, e|`.'])
end
it 'ignores do..end blocks' do
inspect_source(cop,
['def m',
' [0, 1].reduce do |c, d|',
' c + d',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'ignores :reduce symbols' do
inspect_source(cop,
['def m',
' call_method(:reduce) { |a, b| a + b}',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not report when destructuring is used' do
inspect_source(cop,
['def m',
' test.reduce { |a, (id, _)| a + id}',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not report if no block arguments are present' do
inspect_source(cop,
['def m',
' test.reduce { true }',
'end'])
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/single_line_methods_spec.rb 0000664 0000000 0000000 00000007037 13070542236 0027042 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SingleLineMethods do
subject(:cop) { described_class.new(config) }
let(:config) do
RuboCop::Config.new('Style/SingleLineMethods' => cop_config,
'Style/IndentationWidth' => { 'Width' => 2 })
end
let(:cop_config) { { 'AllowIfMethodIsEmpty' => true } }
it 'registers an offense for a single-line method' do
inspect_source(cop,
['def some_method; body end',
'def link_to(name, url); {:name => name}; end',
'def @table.columns; super; end'])
expect(cop.messages).to eq(
['Avoid single-line method definitions.'] * 3
)
end
context 'when AllowIfMethodIsEmpty is disabled' do
let(:cop_config) { { 'AllowIfMethodIsEmpty' => false } }
it 'registers an offense for an empty method' do
inspect_source(cop, ['def no_op; end',
'def self.resource_class=(klass); end',
'def @table.columns; end'])
expect(cop.offenses.size).to eq(3)
end
it 'auto-corrects an empty method' do
corrected = autocorrect_source(cop, 'def x; end')
expect(corrected).to eq(['def x; ',
'end'].join("\n"))
end
end
context 'when AllowIfMethodIsEmpty is enabled' do
let(:cop_config) { { 'AllowIfMethodIsEmpty' => true } }
it 'accepts a single-line empty method' do
inspect_source(cop, ['def no_op; end',
'def self.resource_class=(klass); end',
'def @table.columns; end'])
expect(cop.offenses).to be_empty
end
end
it 'accepts a multi-line method' do
inspect_source(cop, ['def some_method',
' body',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not crash on an method with a capitalized name' do
inspect_source(cop, ['def NoSnakeCase',
'end'])
expect(cop.offenses).to be_empty
end
it 'auto-corrects def with semicolon after method name' do
corrected = autocorrect_source(cop,
[' def some_method; body end # Cmnt'])
expect(corrected).to eq [' # Cmnt',
' def some_method; ',
' body ',
' end '].join("\n")
end
it 'auto-corrects defs with parentheses after method name' do
corrected = autocorrect_source(cop, [' def self.some_method() body end'])
expect(corrected).to eq [' def self.some_method() ',
' body ',
' end'].join("\n")
end
it 'auto-corrects def with argument in parentheses' do
corrected = autocorrect_source(cop, [' def some_method(arg) body end'])
expect(corrected).to eq [' def some_method(arg) ',
' body ',
' end'].join("\n")
end
it 'auto-corrects def with argument and no parentheses' do
corrected = autocorrect_source(cop, [' def some_method arg; body end'])
expect(corrected).to eq [' def some_method arg; ',
' body ',
' end'].join("\n")
end
it 'auto-corrects def with semicolon before end' do
corrected = autocorrect_source(cop, [' def some_method; b1; b2; end'])
expect(corrected).to eq [' def some_method; ',
' b1; ',
' b2; ',
' end'].join("\n")
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/space_after_colon_spec.rb 0000664 0000000 0000000 00000003630 13070542236 0026470 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SpaceAfterColon do
subject(:cop) { described_class.new }
it 'registers an offense for colon without space after it' do
inspect_source(cop, '{a:3}')
expect(cop.messages).to eq(['Space missing after colon.'])
expect(cop.highlights).to eq([':'])
end
it 'accepts colons in symbols' do
inspect_source(cop, 'x = :a')
expect(cop.messages).to be_empty
end
it 'accepts colon in ternary followed by space' do
inspect_source(cop, 'x = w ? a : b')
expect(cop.messages).to be_empty
end
it 'accepts hashes with a space after colons' do
inspect_source(cop, '{a: 3}')
expect(cop.messages).to be_empty
end
it 'accepts hash rockets' do
inspect_source(cop, 'x = {"a"=>1}')
expect(cop.messages).to be_empty
end
it 'accepts if' do
inspect_source(cop, ['x = if w',
' a',
' end'])
expect(cop.messages).to be_empty
end
it 'accepts colons in strings' do
inspect_source(cop, "str << ':'")
expect(cop.messages).to be_empty
end
it 'accepts required keyword arguments' do
inspect_source(cop, ['def f(x:, y:)',
'end'])
expect(cop.messages).to be_empty
end
if RUBY_VERSION >= '2.1'
it 'accepts colons denoting required keyword argument' do
inspect_source(cop, ['def initialize(table:, nodes:)',
'end'])
expect(cop.messages).to be_empty
end
it 'registers an offence if an keyword optional argument has no space' do
inspect_source(cop, ['def m(var:1, other_var: 2)',
'end'])
expect(cop.messages).to eq(['Space missing after colon.'])
end
end
it 'auto-corrects missing space' do
new_source = autocorrect_source(cop, 'def f(a:, b:2); {a:3}; end')
expect(new_source).to eq('def f(a:, b: 2); {a: 3}; end')
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/space_after_comma_spec.rb 0000664 0000000 0000000 00000004710 13070542236 0026452 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SpaceAfterComma do
subject(:cop) { described_class.new(config) }
let(:config) do
RuboCop::Config.new('Style/SpaceInsideHashLiteralBraces' => brace_config)
end
let(:brace_config) { {} }
shared_examples 'ends with an item' do |items, correct_items|
it 'registers an offense' do
inspect_source(cop, source.call(items))
expect(cop.messages).to eq(
['Space missing after comma.']
)
end
it 'does auto-correction' do
new_source = autocorrect_source(cop, source.call(items))
expect(new_source).to eq source.call(correct_items)
end
end
shared_examples 'trailing comma' do |items|
it 'accepts the last comma' do
inspect_source(cop, source.call(items))
expect(cop.messages).to be_empty
end
end
context 'block argument commas without space' do
let(:source) { ->(args) { "each { |#{args}| }" } }
it_behaves_like 'ends with an item', 's,t', 's, t'
it_behaves_like 'trailing comma', 's, t,'
end
context 'array index commas without space' do
let(:source) { ->(items) { "formats[#{items}]" } }
it_behaves_like 'ends with an item', '0,1', '0, 1'
it_behaves_like 'trailing comma', '0,'
end
context 'method call arg commas without space' do
let(:source) { ->(args) { "a(#{args})" } }
it_behaves_like 'ends with an item', '1,2', '1, 2'
end
context 'inside hash braces' do
shared_examples 'common behavior' do
it 'accepts a space between a comma and a closing brace' do
inspect_source(cop, '{ foo:bar, }')
expect(cop.messages).to be_empty
end
end
context 'when EnforcedStyle for SpaceInsideBlockBraces is space' do
let(:brace_config) do
{ 'Enabled' => true, 'EnforcedStyle' => 'space' }
end
it_behaves_like 'common behavior'
it 'registers an offense for no space between a comma and a ' \
'closing brace' do
inspect_source(cop, '{ foo:bar,}')
expect(cop.messages).to eq(['Space missing after comma.'])
end
end
context 'when EnforcedStyle for SpaceInsideBlockBraces is no_space' do
let(:brace_config) do
{ 'Enabled' => true, 'EnforcedStyle' => 'no_space' }
end
it_behaves_like 'common behavior'
it 'accepts no space between a comma and a closing brace' do
inspect_source(cop, '{foo:bar,}')
expect(cop.messages).to be_empty
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/space_after_method_name_spec.rb 0000664 0000000 0000000 00000004012 13070542236 0027631 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SpaceAfterMethodName do
subject(:cop) { described_class.new }
it 'registers an offense for def with space before the parenthesis' do
inspect_source(cop,
['def func (x)',
' a',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for defs with space before the parenthesis' do
inspect_source(cop,
['def self.func (x)',
' a',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'accepts a def without arguments' do
inspect_source(cop,
['def func',
' a',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts a defs without arguments' do
inspect_source(cop,
['def self.func',
' a',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts a def with arguments but no parentheses' do
inspect_source(cop,
['def func x',
' a',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts a defs with arguments but no parentheses' do
inspect_source(cop,
['def self.func x',
' a',
'end'])
expect(cop.offenses).to be_empty
end
it 'auto-corrects unwanted space' do
new_source = autocorrect_source(cop, ['def func (x)',
' a',
'end',
'def self.func (x)',
' a',
'end'])
expect(new_source).to eq(['def func(x)',
' a',
'end',
'def self.func(x)',
' a',
'end'].join("\n"))
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/space_after_not_spec.rb 0000664 0000000 0000000 00000002605 13070542236 0026157 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SpaceAfterNot do
subject(:cop) { described_class.new }
it 'reports an offense for space after !' do
inspect_source(cop, '! something')
expect(cop.messages)
.to eq(['Do not leave space between `!` and its argument.'])
expect(cop.highlights).to eq(['! something'])
end
it 'accepts no space after !' do
inspect_source(cop, '!something')
expect(cop.offenses).to be_empty
end
it 'accepts space after not keyword' do
inspect_source(cop, 'not something')
expect(cop.offenses).to be_empty
end
it 'reports an offense for space after ! with the negated receiver ' \
'wrapped in parentheses' do
inspect_source(cop, '! (model)')
expect(cop.messages)
.to eq(['Do not leave space between `!` and its argument.'])
expect(cop.highlights).to eq(['! (model)'])
end
context 'auto-correct' do
it 'removes redundant space' do
new_source = autocorrect_source(cop, '! something')
expect(new_source).to eq('!something')
end
it 'keeps space after not keyword' do
new_source = autocorrect_source(cop, 'not something')
expect(new_source).to eq('not something')
end
it 'removes redundant space when there is a parentheses' do
new_source = autocorrect_source(cop, '! (model)')
expect(new_source).to eq('!(model)')
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/space_after_semicolon_spec.rb 0000664 0000000 0000000 00000003452 13070542236 0027350 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SpaceAfterSemicolon do
subject(:cop) { described_class.new(config) }
let(:config) do
RuboCop::Config.new('Style/SpaceInsideBlockBraces' => brace_config)
end
let(:brace_config) { {} }
it 'registers an offense for semicolon without space after it' do
inspect_source(cop, 'x = 1;y = 2')
expect(cop.messages).to eq(
['Space missing after semicolon.']
)
end
it 'does not crash if semicolon is the last character of the file' do
inspect_source(cop, 'x = 1;')
expect(cop.messages).to be_empty
end
it 'auto-corrects missing space' do
new_source = autocorrect_source(cop, 'x = 1;y = 2')
expect(new_source).to eq('x = 1; y = 2')
end
context 'inside block braces' do
shared_examples 'common behavior' do
it 'accepts a space between a semicolon and a closing brace' do
inspect_source(cop, 'test { ; }')
expect(cop.messages).to be_empty
end
end
context 'when EnforcedStyle for SpaceInsideBlockBraces is space' do
let(:brace_config) do
{ 'Enabled' => true, 'EnforcedStyle' => 'space' }
end
it_behaves_like 'common behavior'
it 'registers an offense for no space between a semicolon and a ' \
'closing brace' do
inspect_source(cop, 'test { ;}')
expect(cop.messages).to eq(['Space missing after semicolon.'])
end
end
context 'when EnforcedStyle for SpaceInsideBlockBraces is no_space' do
let(:brace_config) do
{ 'Enabled' => true, 'EnforcedStyle' => 'no_space' }
end
it_behaves_like 'common behavior'
it 'accepts no space between a semicolon and a closing brace' do
inspect_source(cop, 'test { ;}')
expect(cop.messages).to be_empty
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/space_around_block_parameters_spec.rb 0000664 0000000 0000000 00000014264 13070542236 0031067 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SpaceAroundBlockParameters, :config do
subject(:cop) { described_class.new(config) }
shared_examples 'common behavior' do
it 'accepts an empty block' do
inspect_source(cop, '{}.each {}')
expect(cop.offenses).to be_empty
end
it 'skips lambda without args' do
inspect_source(cop, '->() { puts "a" }')
expect(cop.offenses).to be_empty
end
end
context 'when EnforcedStyleInsidePipes is no_space' do
let(:cop_config) { { 'EnforcedStyleInsidePipes' => 'no_space' } }
include_examples 'common behavior'
it 'accepts a block with spaces in the right places' do
inspect_source(cop, '{}.each { |x, y| puts x }')
expect(cop.offenses).to be_empty
end
it 'accepts a block with parameters but no body' do
inspect_source(cop, '{}.each { |x, y| }')
expect(cop.offenses).to be_empty
end
it 'accepts a block parameter without preceding space' do
# This is checked by Style/SpaceAfterComma.
inspect_source(cop, '{}.each { |x,y| puts x }')
expect(cop.offenses).to be_empty
end
it 'registers an offense for space before first parameter' do
inspect_source(cop, '{}.each { | x| puts x }')
expect(cop.messages)
.to eq(['Space before first block parameter detected.'])
expect(cop.highlights).to eq([' '])
end
it 'registers an offense for space after last parameter' do
inspect_source(cop, '{}.each { |x, y | puts x }')
expect(cop.messages).to eq(['Space after last block parameter detected.'])
expect(cop.highlights).to eq([' '])
end
it 'registers an offense for no space after closing pipe' do
inspect_source(cop, '{}.each { |x, y|puts x }')
expect(cop.messages).to eq(['Space after closing `|` missing.'])
expect(cop.highlights).to eq(['|'])
end
it 'accepts line break after closing pipe' do
inspect_source(cop, ['{}.each do |x, y|',
' puts x',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for multiple spaces before parameter' do
inspect_source(cop, '{}.each { |x, y| puts x }')
expect(cop.messages)
.to eq(['Extra space before block parameter detected.'])
expect(cop.highlights).to eq([' '])
end
context 'trailing comma' do
it 'registers an offense for space after the last comma' do
inspect_source(cop, '{}.each { |x, | puts x }')
expect(cop.messages)
.to eq(['Space after last block parameter detected.'])
expect(cop.highlights).to eq([' '])
end
it 'accepts no space after the last comma' do
inspect_source(cop, '{}.each { |x,| puts x }')
expect(cop.offenses).to be_empty
end
end
it 'auto-corrects offenses' do
new_source = autocorrect_source(cop,
'{}.each { | x=5, (y,*z) |puts x }')
expect(new_source).to eq('{}.each { |x=5, (y,*z)| puts x }')
end
end
context 'when EnforcedStyleInsidePipes is space' do
let(:cop_config) { { 'EnforcedStyleInsidePipes' => 'space' } }
include_examples 'common behavior'
it 'accepts a block with spaces in the right places' do
inspect_source(cop, '{}.each { | x, y | puts x }')
expect(cop.offenses).to be_empty
end
it 'accepts a block with parameters but no body' do
inspect_source(cop, '{}.each { | x, y | }')
expect(cop.offenses).to be_empty
end
it 'accepts a block parameter without preceding space' do
# This is checked by Style/SpaceAfterComma.
inspect_source(cop, '{}.each { | x,y | puts x }')
expect(cop.offenses).to be_empty
end
it 'registers an offense for no space before first parameter' do
inspect_source(cop, '{}.each { |x | puts x }')
expect(cop.messages)
.to eq(['Space before first block parameter missing.'])
expect(cop.highlights).to eq(['x'])
end
it 'registers an offense for no space after last parameter' do
inspect_source(cop, '{}.each { | x, y| puts x }')
expect(cop.messages).to eq(['Space after last block parameter missing.'])
expect(cop.highlights).to eq(['y'])
end
it 'registers an offense for extra space before first parameter' do
inspect_source(cop, '{}.each { | x | puts x }')
expect(cop.messages)
.to eq(['Extra space before first block parameter detected.'])
expect(cop.highlights).to eq([' '])
end
it 'registers an offense for multiple spaces after last parameter' do
inspect_source(cop, '{}.each { | x, y | puts x }')
expect(cop.messages)
.to eq(['Extra space after last block parameter detected.'])
expect(cop.highlights).to eq([' '])
end
it 'registers an offense for no space after closing pipe' do
inspect_source(cop, '{}.each { | x, y |puts x }')
expect(cop.messages).to eq(['Space after closing `|` missing.'])
expect(cop.highlights).to eq(['|'])
end
it 'accepts line break after closing pipe' do
inspect_source(cop, ['{}.each do | x, y |',
' puts x',
'end'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for multiple spaces before parameter' do
inspect_source(cop, '{}.each { | x, y | puts x }')
expect(cop.messages)
.to eq(['Extra space before block parameter detected.'])
expect(cop.highlights).to eq([' '])
end
context 'trailing comma' do
it 'accepts space after the last comma' do
inspect_source(cop, '{}.each { | x, | puts x }')
expect(cop.offenses).to be_empty
end
it 'registers an offense for no space after the last comma' do
inspect_source(cop, '{}.each { | x,| puts x }')
expect(cop.messages)
.to eq(['Space after last block parameter missing.'])
expect(cop.highlights).to eq(['x'])
end
end
it 'auto-corrects offenses' do
new_source = autocorrect_source(cop,
'{}.each { | x=5, (y,*z)|puts x }')
expect(new_source).to eq('{}.each { | x=5, (y,*z) | puts x }')
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/space_around_equals_in_parameter_default_spec.rb 0000664 0000000 0000000 00000006717 13070542236 0033302 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SpaceAroundEqualsInParameterDefault, :config do
subject(:cop) { described_class.new(config) }
context 'when EnforcedStyle is space' do
let(:cop_config) { { 'EnforcedStyle' => 'space' } }
it 'registers an offense for default value assignment without space' do
inspect_source(cop, ['def f(x, y=0, z= 1)',
'end'])
expect(cop.messages)
.to eq(['Surrounding space missing in default value assignment.'] * 2)
expect(cop.highlights).to eq(['=', '= '])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'registers an offense for assignment empty string without space' do
inspect_source(cop, ['def f(x, y="", z=1)',
'end'])
expect(cop.offenses.size).to eq(2)
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'no_space')
end
it 'registers an offense for assignment of empty list without space' do
inspect_source(cop, ['def f(x, y=[])',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'accepts default value assignment with space' do
inspect_source(cop, ['def f(x, y = 0, z = {})',
'end'])
expect(cop.messages).to be_empty
end
it 'auto-corrects missing space' do
new_source = autocorrect_source(cop, ['def f(x, y=0, z=1)', 'end'])
expect(new_source).to eq(['def f(x, y = 0, z = 1)', 'end'].join("\n"))
end
it 'accepts default value assignment with spaces and unary + operator' do
inspect_source(cop, ['def f(x, y = +1, z = {})',
'end'])
expect(cop.messages).to be_empty
end
it 'auto-corrects missing space for arguments with unary operators' do
new_source = autocorrect_source(cop, ['def f(x=-1, y= 0, z =+1)', 'end'])
expect(new_source).to eq(['def f(x = -1, y = 0, z = +1)',
'end'].join("\n"))
end
end
context 'when EnforcedStyle is no_space' do
let(:cop_config) { { 'EnforcedStyle' => 'no_space' } }
it 'registers an offense for default value assignment with space' do
inspect_source(cop, ['def f(x, y = 0, z =1, w= 2)',
'end'])
expect(cop.messages)
.to eq(['Surrounding space detected in default value assignment.'] * 3)
expect(cop.highlights).to eq([' = ', ' =', '= '])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'registers an offense for assignment empty string with space' do
inspect_source(cop, ['def f(x, y = "", z = 1)',
'end'])
expect(cop.offenses.size).to eq(2)
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'space')
end
it 'registers an offense for assignment of empty list with space' do
inspect_source(cop, ['def f(x, y = [])',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'accepts default value assignment without space' do
inspect_source(cop, ['def f(x, y=0, z={})',
'end'])
expect(cop.messages).to be_empty
end
it 'auto-corrects unwanted space' do
new_source = autocorrect_source(cop, ['def f(x, y = 0, z= 1, w= 2)',
'end'])
expect(new_source).to eq(['def f(x, y=0, z=1, w=2)',
'end'].join("\n"))
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/space_around_keyword_spec.rb 0000664 0000000 0000000 00000021702 13070542236 0027231 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SpaceAroundKeyword do
subject(:cop) { described_class.new }
shared_examples 'missing before' do |highlight, expr, correct|
it 'registers an offense for missing space before keyword in ' \
"`#{expr}`" do
inspect_source(cop, expr)
expect(cop.messages)
.to eq(["Space before keyword `#{highlight}` is missing."])
expect(cop.highlights).to eq([highlight])
end
it 'auto-corrects' do
expect(autocorrect_source(cop, expr)).to eq correct
end
end
shared_examples 'missing after' do |highlight, expr, correct|
it 'registers an offense for missing space after keyword in ' \
"`#{expr}`" do
inspect_source(cop, expr)
expect(cop.messages)
.to eq(["Space after keyword `#{highlight}` is missing."])
expect(cop.highlights).to eq([highlight])
end
it 'auto-corrects' do
expect(autocorrect_source(cop, expr)).to eq correct
end
end
shared_examples 'accept before' do |after, expr|
it "accepts `#{after}` before keyword in `#{expr}`" do
inspect_source(cop, expr)
expect(cop.offenses).to be_empty
end
end
shared_examples 'accept after' do |after, expr|
it "accepts `#{after}` after keyword in `#{expr}`" do
inspect_source(cop, expr)
expect(cop.offenses).to be_empty
end
end
shared_examples 'accept around' do |after, expr|
it "accepts `#{after}` around keyword in `#{expr}`" do
inspect_source(cop, expr)
expect(cop.offenses).to be_empty
end
end
it_behaves_like 'missing after', 'BEGIN', 'BEGIN{}', 'BEGIN {}'
it_behaves_like 'missing after', 'END', 'END{}', 'END {}'
it_behaves_like 'missing before', 'and', '1and 2', '1 and 2'
it_behaves_like 'missing after', 'and', '1 and(2)', '1 and (2)'
it_behaves_like 'missing after', 'begin', 'begin"" end', 'begin "" end'
it_behaves_like 'missing after', 'break', 'break""', 'break ""'
it_behaves_like 'accept after', '(', 'break(1)'
it_behaves_like 'missing after', 'case', 'case"" when 1; end',
'case "" when 1; end'
it_behaves_like 'missing before', 'do', 'a "b"do end', 'a "b" do end'
it_behaves_like 'missing after', 'do', 'a do|x| end', 'a do |x| end'
it_behaves_like 'missing before', 'do', 'while 1do end', 'while 1 do end'
it_behaves_like 'missing after', 'do', 'while 1 do"x" end',
'while 1 do "x" end'
it_behaves_like 'missing before', 'do', 'until 1do end', 'until 1 do end'
it_behaves_like 'missing after', 'do', 'until 1 do"x" end',
'until 1 do "x" end'
it_behaves_like 'missing before', 'do', 'for x in []do end',
'for x in [] do end'
it_behaves_like 'missing after', 'do', 'for x in [] do"x" end',
'for x in [] do "x" end'
it_behaves_like 'missing before', 'end', 'begin "a"end', 'begin "a" end'
it_behaves_like 'missing before', 'end', 'if a; "b"end', 'if a; "b" end'
it_behaves_like 'missing before', 'end', 'a do "a"end', 'a do "a" end'
it_behaves_like 'missing before', 'end', 'while 1 do "x"end',
'while 1 do "x" end'
it_behaves_like 'missing before', 'end', 'until 1 do "x"end',
'until 1 do "x" end'
it_behaves_like 'missing before', 'end', 'for x in [] do "x"end',
'for x in [] do "x" end'
it_behaves_like 'accept after', '.', 'begin end.inspect'
it_behaves_like 'missing before', 'else', 'if a; ""else end',
'if a; "" else end'
it_behaves_like 'missing after', 'else', 'if a; else"" end',
'if a; else "" end'
it_behaves_like 'missing before', 'else', 'begin rescue; ""else end',
'begin rescue; "" else end'
it_behaves_like 'missing after', 'else', 'begin rescue; else"" end',
'begin rescue; else "" end'
it_behaves_like 'missing before', 'else', 'case a; when b; ""else end',
'case a; when b; "" else end'
it_behaves_like 'missing after', 'else', 'case a; when b; else"" end',
'case a; when b; else "" end'
it_behaves_like 'missing before', 'elsif', 'if a; ""elsif b; end',
'if a; "" elsif b; end'
it_behaves_like 'missing after', 'elsif', 'if a; elsif""; end',
'if a; elsif ""; end'
it_behaves_like 'missing before', 'elsif', 'if a; ""elsif b; end',
'if a; "" elsif b; end'
it_behaves_like 'missing after', 'elsif', 'if a; elsif""; end',
'if a; elsif ""; end'
it_behaves_like 'missing before', 'ensure', 'begin ""ensure end',
'begin "" ensure end'
it_behaves_like 'missing after', 'ensure', 'begin ensure"" end',
'begin ensure "" end'
it_behaves_like 'missing after', 'if', 'if""; end', 'if ""; end'
it_behaves_like 'missing after', 'next', 'next""', 'next ""'
it_behaves_like 'accept after', '(', 'next(1)'
it_behaves_like 'missing after', 'not', 'not""', 'not ""'
it_behaves_like 'accept after', '(', 'not(1)'
it_behaves_like 'missing before', 'or', '1or 2', '1 or 2'
it_behaves_like 'missing after', 'or', '1 or(2)', '1 or (2)'
it_behaves_like 'missing before', 'rescue', '""rescue a', '"" rescue a'
it_behaves_like 'missing after', 'rescue', 'a rescue""', 'a rescue ""'
it_behaves_like 'accept after', 'rescue', 'begin; rescue(Error); end',
'begin; rescue(Error); end'
it_behaves_like 'missing after', 'return', 'return""', 'return ""'
it_behaves_like 'accept after', '(', 'return(1)'
it_behaves_like 'missing after', 'super', 'super""', 'super ""'
it_behaves_like 'accept after', '(', 'super(1)'
it_behaves_like 'missing after', 'super', 'super{}', 'super {}'
it_behaves_like 'accept after', '(', 'defined?(1)'
it_behaves_like 'missing after', 'defined?', 'defined?1', 'defined? 1'
it_behaves_like 'missing before', 'then', 'if ""then a end',
'if "" then a end'
it_behaves_like 'missing after', 'then', 'if a then"" end',
'if a then "" end'
it_behaves_like 'missing after', 'unless', 'unless""; end', 'unless ""; end'
it_behaves_like 'missing before', 'until', '1until ""', '1 until ""'
it_behaves_like 'missing after', 'until', '1 until""', '1 until ""'
it_behaves_like 'missing before', 'when', 'case ""when a; end',
'case "" when a; end'
it_behaves_like 'missing after', 'when', 'case a when""; end',
'case a when ""; end'
it_behaves_like 'missing before', 'while', '1while ""', '1 while ""'
it_behaves_like 'missing after', 'while', '1 while""', '1 while ""'
it_behaves_like 'missing after', 'yield', 'yield""', 'yield ""'
it_behaves_like 'accept after', '(', 'yield(1)'
it_behaves_like 'accept after', '+', '+begin end'
it_behaves_like 'missing after', 'begin', 'begin+1 end', 'begin +1 end'
# Common exceptions
it_behaves_like 'accept after', '\\', "test do\\\nend"
it_behaves_like 'accept after', '\n', "test do\nend"
it_behaves_like 'accept around', '()', '(next)'
it_behaves_like 'accept before', '!', '!yield'
it_behaves_like 'accept after', '.', 'yield.method'
it_behaves_like 'accept before', '!', '!yield.method'
it_behaves_like 'accept before', '!', '!super.method'
context '&.', :ruby23 do
it_behaves_like 'accept after', '&.', 'super&.foo'
it_behaves_like 'accept after', '&.', 'yield&.foo'
end
it_behaves_like 'accept after', '[', 'super[1]'
it_behaves_like 'accept after', '[', 'yield[1]'
# Style/SpaceAroundBlockParameters
it_behaves_like 'accept before', '|', 'loop { |x|break }'
# Style/SpaceAroundOperators
it_behaves_like 'accept before', '=', 'a=begin end'
it_behaves_like 'accept before', '==', 'a==begin end'
it_behaves_like 'accept before', '+', 'a+begin end'
it_behaves_like 'accept before', '+', 'a+begin; end.method'
it_behaves_like 'accept before', '-', 'a-begin end'
it_behaves_like 'accept before', '*', 'a*begin end'
it_behaves_like 'accept before', '**', 'a**begin end'
it_behaves_like 'accept before', '/', 'a/begin end'
it_behaves_like 'accept before', '<', 'a', 'a>begin end'
it_behaves_like 'accept before', '&&', 'a&&begin end'
it_behaves_like 'accept before', '||', 'a||begin end'
it_behaves_like 'accept before', '=*', 'a=*begin end'
# Style/SpaceBeforeBlockBraces
it_behaves_like 'accept after', '{', 'loop{}'
# Style/SpaceBeforeComma, Style/SpaceAfterComma
it_behaves_like 'accept around', ',', 'a 1,next,1'
# Style/SpaceBeforeComment
it_behaves_like 'accept after', '#', 'next#comment'
# Style/SpaceBeforeSemicolon, Style/SpaceAfterSemicolon
it_behaves_like 'accept around', ';', 'test do;end'
# Style/SpaceInsideBlockBraces
it_behaves_like 'accept around', '{}', 'loop {next}'
# Style/SpaceInsideBrackets
it_behaves_like 'accept around', '[]', '[begin end]'
# Style/SpaceInsideHashLiteralBraces
it_behaves_like 'accept around', '{}', '{a: begin end}'
# Style/SpaceInsideStringInterpolation
it_behaves_like 'accept around', '{}', '"#{begin end}"'
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/space_around_operators_spec.rb 0000664 0000000 0000000 00000060352 13070542236 0027567 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SpaceAroundOperators do
subject(:cop) { described_class.new(config) }
let(:config) do
RuboCop::Config
.new(
'Style/AlignHash' => { 'EnforcedHashRocketStyle' => hash_style },
'Style/SpaceAroundOperators' => {
'AllowForAlignment' => allow_for_alignment
}
)
end
let(:hash_style) { 'key' }
let(:allow_for_alignment) { true }
it 'accepts operator surrounded by tabs' do
inspect_source(cop, "a\t+\tb")
expect(cop.messages).to be_empty
end
it 'accepts operator symbols' do
inspect_source(cop, 'func(:-)')
expect(cop.messages).to be_empty
end
it 'accepts ranges' do
inspect_source(cop, 'a, b = (1..2), (1...3)')
expect(cop.messages).to be_empty
end
it 'accepts scope operator' do
source = '@io.class == Zlib::GzipWriter'
inspect_source(cop, source)
expect(cop.messages).to be_empty
end
it 'accepts ::Kernel::raise' do
source = '::Kernel::raise IllegalBlockError.new'
inspect_source(cop, source)
expect(cop.messages).to be_empty
end
it 'accepts exclamation point negation' do
inspect_source(cop, 'x = !a&&!b')
expect(cop.messages).to eq(
['Surrounding space missing for operator `&&`.']
)
end
it 'accepts exclamation point definition' do
inspect_source(cop, [' def !',
' !__getobj__',
' end'])
expect(cop.offenses).to be_empty
expect(cop.messages).to be_empty
end
it 'accepts a unary' do
inspect_source(cop,
[' def bm(label_width = 0, *labels, &blk)',
' benchmark(CAPTION, label_width, FORMAT,',
' *labels, &blk)',
' end',
'',
' def each &block',
' +11',
' end',
'',
' def self.search *args',
' end',
'',
' def each *args',
' end',
''])
expect(cop.messages).to be_empty
end
it 'accepts splat operator' do
inspect_source(cop, 'return *list if options')
expect(cop.messages).to be_empty
end
it 'accepts def of operator' do
inspect_source(cop, ['def +(other); end',
'def self.===(other); end'])
expect(cop.messages).to be_empty
end
it 'accepts an operator at the end of a line' do
inspect_source(cop,
["['Favor unless over if for negative ' +",
" 'conditions.'] * 2"])
expect(cop.messages).to eq([])
end
it 'accepts an assignment with spaces' do
inspect_source(cop, 'x = 0')
expect(cop.offenses).to be_empty
end
it 'accepts an assignment by `for` statement' do
inspect_source(cop,
['for a in [] do; end',
'for A in [] do; end',
'for @a in [] do; end',
'for @@a in [] do; end'])
expect(cop.offenses).to be_empty
end
it 'accepts an operator called with method syntax' do
inspect_source(cop, 'Date.today.+(1).to_s')
expect(cop.offenses).to be_empty
end
it 'accepts operators with spaces' do
inspect_source(cop,
['x += a + b - c * d / e % f ^ g | h & i || j',
'y -= k && l'])
expect(cop.messages).to eq([])
end
it "accepts some operators that are exceptions & don't need spaces" do
inspect_source(cop, ['(1..3)',
'ActionController::Base',
'each { |s, t| }'])
expect(cop.messages).to eq([])
end
it 'accepts an assignment followed by newline' do
inspect_source(cop, ['x =', '0'])
expect(cop.offenses).to be_empty
end
it 'accepts an operator at the beginning of a line' do
inspect_source(cop, ['a = b \\',
' && c'])
expect(cop.offenses).to be_empty
end
it 'registers an offenses for exponent operator with spaces' do
inspect_source(cop, 'x = a * b ** 2')
expect(cop.messages).to eq(
['Space around operator `**` detected.']
)
end
it 'auto-corrects unwanted space around **' do
new_source = autocorrect_source(cop, ['x = a * b ** 2',
'y = a * b** 2'])
expect(new_source).to eq(['x = a * b**2',
'y = a * b**2'].join("\n"))
end
it 'accepts exponent operator without spaces' do
inspect_source(cop, 'x = a * b**2')
expect(cop.offenses).to be_empty
end
it 'accepts unary operators without space' do
inspect_source(cop, ['[].map(&:size)',
'a.(b)',
'-3',
'arr.collect { |e| -e }',
'x = +2'])
expect(cop.messages).to eq([])
end
it 'accepts [arg] without space' do
inspect_source(cop, 'files[2]')
expect(cop.messages).to eq([])
end
it 'accepts [] without space' do
inspect_source(cop, 'files[]')
expect(cop.messages).to eq([])
end
it 'accepts []= without space' do
inspect_source(cop, 'files[:key], files[:another] = method')
expect(cop.messages).to eq([])
end
it 'accepts argument default values without space' do
# These are handled by SpaceAroundEqualsInParameterDefault,
# so SpaceAroundOperators leaves them alone.
inspect_source(cop,
['def init(name=nil)',
'end'])
expect(cop.messages).to be_empty
end
it 'accepts the construct class <2, a: b }') }
context 'and Style/AlignHash:EnforcedHashRocketStyle is key' do
let(:hash_style) { 'key' }
it 'registers an offense for a hash rocket without spaces' do
expect(cop.messages)
.to eq(['Surrounding space missing for operator `=>`.'])
end
end
context 'and Style/AlignHash:EnforcedHashRocketStyle is table' do
let(:hash_style) { 'table' }
it 'registers an offense for a hash rocket without spaces' do
expect(cop.messages)
.to eq(['Surrounding space missing for operator `=>`.'])
end
end
end
context 'when a hash literal is on multiple lines' do
before do
inspect_source(cop, ['{',
' 1=>2,',
' a: b',
'}'])
end
context 'and Style/AlignHash:EnforcedHashRocketStyle is key' do
let(:hash_style) { 'key' }
it 'registers an offense for a hash rocket without spaces' do
expect(cop.messages)
.to eq(['Surrounding space missing for operator `=>`.'])
end
end
context 'and Style/AlignHash:EnforcedHashRocketStyle is table' do
let(:hash_style) { 'table' }
it "doesn't register an offense for a hash rocket without spaces" do
expect(cop.offenses).to be_empty
end
end
end
it 'registers an offense for match operators without space' do
inspect_source(cop, ['x=~/abc/',
'y !~/abc/'])
expect(cop.messages)
.to eq(['Surrounding space missing for operator `=~`.',
'Surrounding space missing for operator `!~`.'])
end
it 'registers an offense for various assignments without space' do
inspect_source(cop, ['x||=0',
'y&&=0',
'z*=2',
'@a=0',
'@@a=0',
'a,b=0',
'A=0',
'x[3]=0',
'$A=0',
'A||=0'])
expect(cop.messages)
.to eq(['Surrounding space missing for operator `||=`.',
'Surrounding space missing for operator `&&=`.',
'Surrounding space missing for operator `*=`.',
'Surrounding space missing for operator `=`.',
'Surrounding space missing for operator `=`.',
'Surrounding space missing for operator `=`.',
'Surrounding space missing for operator `=`.',
'Surrounding space missing for operator `=`.',
'Surrounding space missing for operator `=`.',
'Surrounding space missing for operator `||=`.'])
end
it 'registers an offense for equality operators without space' do
inspect_source(cop, ['x==0', 'y!=0', 'Hash===z'])
expect(cop.messages)
.to eq(['Surrounding space missing for operator `==`.',
'Surrounding space missing for operator `!=`.',
'Surrounding space missing for operator `===`.'])
end
it 'registers an offense for - without space with negative lhs operand' do
inspect_source(cop, '-1-arg')
expect(cop.messages)
.to eq(['Surrounding space missing for operator `-`.'])
end
it 'registers an offense for inheritance < without space' do
inspect_source(cop, ['class ShowSourceTestClasse',
'end'])
expect(cop.messages)
.to eq(['Surrounding space missing for operator `=>`.'])
end
it "doesn't eat a newline when auto-correcting" do
new_source = autocorrect_source(cop, ["'Here is a'+",
"'joined string'+",
"'across three lines'"])
expect(new_source).to eq(["'Here is a' +",
"'joined string' +",
"'across three lines'"].join("\n"))
end
it "doesn't register an offense for operators with newline on right" do
inspect_source(cop, ["'Here is a' +",
"'joined string' +",
"'across three lines'"])
expect(cop.offenses).to be_empty
end
end
describe 'extra space around operators' do
shared_examples 'modifier with extra space' do |keyword|
it "registers an offense in presence of modifier #{keyword} statement" do
src = ["a = 1 #{keyword} condition",
'c = 2']
inspect_source(cop, src)
expect(cop.offenses.map(&:line)).to eq([1, 2])
expect(cop.messages).to eq(
['Operator `=` should be surrounded by a single space.'] * 2
)
new_source = autocorrect_source(cop, src)
expect(new_source)
.to eq(src.map { |line| line.sub(/\s*=\s*/, ' = ') }.join("\n"))
end
end
it 'registers an offense for assignment with many spaces on either side' do
inspect_source(cop, ['x = 0',
'y += 0',
'z[0] = 0'])
expect(cop.messages)
.to eq(['Operator `=` should be surrounded by a single space.',
'Operator `+=` should be surrounded by a single space.',
'Operator `=` should be surrounded by a single space.'])
end
it 'auto-corrects assignment with too many spaces on either side' do
new_source = autocorrect_source(cop, ['x = 0',
'y = 0',
'z = 0'])
expect(new_source).to eq(['x = 0', 'y = 0', 'z = 0'].join("\n"))
end
it 'registers an offense for ternary operator with too many spaces' do
inspect_source(cop, 'x == 0 ? 1 : 2')
expect(cop.messages).to eq(
['Operator `?` should be surrounded by a single space.',
'Operator `:` should be surrounded by a single space.']
)
end
it 'auto-corrects a ternary operator too many spaces' do
new_source = autocorrect_source(cop, 'x == 0 ? 1 : 2')
expect(new_source).to eq('x == 0 ? 1 : 2')
end
it_behaves_like 'modifier with extra space', 'if'
it_behaves_like 'modifier with extra space', 'unless'
it_behaves_like 'modifier with extra space', 'while'
it_behaves_like 'modifier with extra space', 'until'
it 'registers an offense for binary operators that could be unary' do
inspect_source(cop, ['a - 3',
'x & 0xff',
'z + 0'])
expect(cop.messages).to eq(
['Operator `-` should be surrounded by a single space.',
'Operator `&` should be surrounded by a single space.',
'Operator `+` should be surrounded by a single space.']
)
end
it 'auto-corrects missing space in binary operators that could be unary' do
new_source = autocorrect_source(cop, ['a - 3',
'x & 0xff',
'z + 0'])
expect(new_source).to eq(['a - 3', 'x & 0xff', 'z + 0'].join("\n"))
end
it 'registers an offense for arguments to a method' do
inspect_source(cop, 'puts 1 + 2')
expect(cop.messages).to eq(
['Operator `+` should be surrounded by a single space.']
)
end
it 'auto-corrects missing space in arguments to a method' do
new_source = autocorrect_source(cop, 'puts 1 + 2')
expect(new_source).to eq('puts 1 + 2')
end
it 'registers an offense for operators with too many spaces' do
inspect_source(cop,
['x += a + b - c * d / e % f ^ g | h & i || j',
'y -= k && l'])
expect(cop.messages)
.to eq(['Operator `+=` should be surrounded by a single space.',
'Operator `+` should be surrounded by a single space.',
'Operator `-` should be surrounded by a single space.',
'Operator `*` should be surrounded by a single space.',
'Operator `/` should be surrounded by a single space.',
'Operator `%` should be surrounded by a single space.',
'Operator `^` should be surrounded by a single space.',
'Operator `|` should be surrounded by a single space.',
'Operator `&` should be surrounded by a single space.',
'Operator `||` should be surrounded by a single space.',
'Operator `-=` should be surrounded by a single space.',
'Operator `&&` should be surrounded by a single space.'])
end
it 'auto-corrects missing space' do
new_source = autocorrect_source(
cop,
['x += a + b - c * d / e % f ^ g | h & i || j',
'y -= k && l']
)
expect(new_source).to eq(['x += a + b - c * d / e % f ^ g | h & i || j',
'y -= k && l'].join("\n"))
end
it 'registers an offense for a setter call with too many spaces' do
inspect_source(cop, 'x.y = 2')
expect(cop.messages).to eq(
['Operator `=` should be surrounded by a single space.']
)
end
it 'registers an offense for a hash rocket with too many spaces' do
inspect_source(cop, '{ 1 => 2, a: b }')
expect(cop.messages).to eq(
['Operator `=>` should be surrounded by a single space.']
)
end
it 'registers an offense for a hash rocket with an extra space' \
'on multiple line' do
inspect_source(cop, ['{',
' 1 => 2',
'}'])
expect(cop.messages).to eq(
['Operator `=>` should be surrounded by a single space.']
)
end
it 'accepts for a hash rocket with an extra space for alignment' \
'on multiple line' do
inspect_source(cop, ['{',
' 1 => 2,',
' 11 => 3',
'}'])
expect(cop.offenses).to be_empty
end
context 'when does not allowed for alignment' do
let(:allow_for_alignment) { false }
it 'accepts an extra space' do
inspect_source(cop, ['{',
' 1 => 2,',
' 11 => 3',
'}'])
expect(cop.messages).to eq(
['Operator `=>` should be surrounded by a single space.']
)
end
end
it 'registers an offense for match operators with too many spaces' do
inspect_source(cop, ['x =~ /abc/',
'y !~ /abc/'])
expect(cop.messages)
.to eq(['Operator `=~` should be surrounded by a single space.',
'Operator `!~` should be surrounded by a single space.'])
end
it 'registers an offense for various assignments with too many spaces' do
inspect_source(cop, ['x ||= 0',
'y &&= 0',
'z *= 2',
'@a = 0',
'@@a = 0',
'a,b = 0',
'A = 0',
'x[3] = 0',
'$A = 0',
'A ||= 0',
'A += 0'])
expect(cop.messages)
.to eq(['Operator `||=` should be surrounded by a single space.',
'Operator `&&=` should be surrounded by a single space.',
'Operator `*=` should be surrounded by a single space.',
'Operator `=` should be surrounded by a single space.',
'Operator `=` should be surrounded by a single space.',
'Operator `=` should be surrounded by a single space.',
'Operator `=` should be surrounded by a single space.',
'Operator `=` should be surrounded by a single space.',
'Operator `=` should be surrounded by a single space.',
'Operator `||=` should be surrounded by a single space.',
'Operator `+=` should be surrounded by a single space.'])
end
it 'registers an offense for equality operators with too many spaces' do
inspect_source(cop, ['x == 0', 'y != 0', 'Hash === z'])
expect(cop.messages)
.to eq(['Operator `==` should be surrounded by a single space.',
'Operator `!=` should be surrounded by a single space.',
'Operator `===` should be surrounded by a single space.'])
end
it 'registers an offense for - with too many spaces with ' \
'negative lhs operand' do
inspect_source(cop, '-1 - arg')
expect(cop.messages)
.to eq(['Operator `-` should be surrounded by a single space.'])
end
it 'registers an offense for inheritance < with too many spaces' do
inspect_source(cop,
['class ShowSourceTestClass < ShowSourceTestSuperClass',
'end'])
expect(cop.messages)
.to eq(['Operator `<` should be surrounded by a single space.'])
end
it 'registers an offense for hash rocket with too many spaces at rescue' do
inspect_source(cop, ['begin',
'rescue Exception => e',
'end'])
expect(cop.messages)
.to eq(['Operator `=>` should be surrounded by a single space.'])
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/space_before_block_braces_spec.rb 0000664 0000000 0000000 00000005172 13070542236 0030133 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SpaceBeforeBlockBraces, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'EnforcedStyle' => 'space' } }
context 'when EnforcedStyle is space' do
it 'accepts braces surrounded by spaces' do
inspect_source(cop, 'each { puts }')
expect(cop.messages).to be_empty
expect(cop.highlights).to be_empty
end
it 'registers an offense for left brace without outer space' do
inspect_source(cop, 'each{ puts }')
expect(cop.messages).to eq(['Space missing to the left of {.'])
expect(cop.highlights).to eq(['{'])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'no_space')
end
it 'registers an offense for opposite + correct style' do
inspect_source(cop,
['each{ puts }',
'each { puts }'])
expect(cop.messages).to eq(['Space missing to the left of {.'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'registers an offense for multiline block where left brace has no ' \
'outer space' do
inspect_source(cop, ['foo.map{ |a|',
' a.bar.to_s',
'}'])
expect(cop.messages).to eq(['Space missing to the left of {.'])
expect(cop.highlights).to eq(['{'])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'no_space')
end
it 'auto-corrects missing space' do
new_source = autocorrect_source(cop, 'each{}')
expect(new_source).to eq('each {}')
end
end
context 'when EnforcedStyle is no_space' do
let(:cop_config) { { 'EnforcedStyle' => 'no_space' } }
it 'registers an offense for braces surrounded by spaces' do
inspect_source(cop, 'each { puts }')
expect(cop.messages).to eq(['Space detected to the left of {.'])
expect(cop.highlights).to eq([' '])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'space')
end
it 'registers an offense for correct + opposite style' do
inspect_source(cop,
['each{ puts }',
'each { puts }'])
expect(cop.messages).to eq(['Space detected to the left of {.'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'auto-corrects unwanted space' do
new_source = autocorrect_source(cop, 'each {}')
expect(new_source).to eq('each{}')
end
it 'accepts left brace without outer space' do
inspect_source(cop, 'each{ puts }')
expect(cop.messages).to be_empty
expect(cop.highlights).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/space_before_comma_spec.rb 0000664 0000000 0000000 00000002472 13070542236 0026616 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SpaceBeforeComma do
subject(:cop) { described_class.new }
it 'registers an offense for block argument with space before comma' do
inspect_source(cop, 'each { |s , t| }')
expect(cop.messages).to eq(
['Space found before comma.']
)
end
it 'registers an offense for array index with space before comma' do
inspect_source(cop, 'formats[0 , 1]')
expect(cop.messages).to eq(
['Space found before comma.']
)
end
it 'registers an offense for method call arg with space before comma' do
inspect_source(cop, 'a(1 , 2)')
expect(cop.messages).to eq(
['Space found before comma.']
)
end
it 'does not register an offense for no spaces before comma' do
inspect_source(cop, 'a(1, 2)')
expect(cop.messages).to be_empty
end
it 'auto-corrects space before comma' do
new_source = autocorrect_source(cop,
'each { |s , t| a(1 , formats[0 , 1])}')
expect(new_source).to eq('each { |s, t| a(1, formats[0, 1])}')
end
it 'handles more than one space before a comma' do
new_source = autocorrect_source(cop,
'each { |s , t| a(1 , formats[0 , 1])}')
expect(new_source).to eq('each { |s, t| a(1, formats[0, 1])}')
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/space_before_comment_spec.rb 0000664 0000000 0000000 00000001625 13070542236 0027163 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SpaceBeforeComment do
subject(:cop) { described_class.new }
it 'registers an offense for missing space before an EOL comment' do
inspect_source(cop, 'a += 1# increment')
expect(cop.highlights).to eq(['# increment'])
end
it 'accepts an EOL comment with a preceding space' do
inspect_source(cop, 'a += 1 # increment')
expect(cop.offenses).to be_empty
end
it 'accepts a comment that begins a line' do
inspect_source(cop, '# comment')
expect(cop.offenses).to be_empty
end
it 'accepts a doc comment' do
inspect_source(cop, ['=begin',
'Doc comment',
'=end'])
expect(cop.offenses).to be_empty
end
it 'auto-corrects missing space' do
new_source = autocorrect_source(cop, 'a += 1# increment')
expect(new_source).to eq('a += 1 # increment')
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/space_before_first_arg_spec.rb 0000664 0000000 0000000 00000006262 13070542236 0027503 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SpaceBeforeFirstArg, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'AllowForAlignment' => true } }
context 'for method calls without parentheses' do
it 'registers an offense for method call with two spaces before the ' \
'first arg' do
inspect_source(cop, ['something x',
'a.something y, z'])
expect(cop.messages)
.to eq(['Put one space between the method name and the first ' \
'argument.'] * 2)
expect(cop.highlights).to eq([' ', ' '])
end
it 'auto-corrects extra space' do
new_source = autocorrect_source(cop, ['something x',
'a.something y, z'])
expect(new_source).to eq(['something x',
'a.something y, z'].join("\n"))
end
it 'accepts a method call with one space before the first arg' do
inspect_source(cop, ['something x',
'a.something y, z'])
expect(cop.offenses).to be_empty
end
it 'accepts + operator' do
inspect_source(cop, ['something +',
' x'])
expect(cop.offenses).to be_empty
end
it 'accepts setter call' do
inspect_source(cop, ['something.x =',
' y'])
expect(cop.offenses).to be_empty
end
it 'accepts multiple space containing line break' do
inspect_source(cop, ['something \\',
' x'])
expect(cop.offenses).to be_empty
end
context 'when AllowForAlignment is true' do
it 'accepts method calls with aligned first arguments' do
inspect_source(cop, ['form.inline_input :full_name, as: :string',
'form.disabled_input :password, as: :passwd',
'form.masked_input :zip_code, as: :string',
'form.masked_input :email_address, as: :email',
'form.masked_input :phone_number, as: :tel'])
expect(cop.offenses).to be_empty
end
end
context 'when AllowForAlignment is false' do
let(:cop_config) { { 'AllowForAlignment' => false } }
it 'does not accept method calls with aligned first arguments' do
inspect_source(cop, ['form.inline_input :full_name, as: :string',
'form.disabled_input :password, as: :passwd',
'form.masked_input :zip_code, as: :string',
'form.masked_input :email_address, as: :email',
'form.masked_input :phone_number, as: :tel'])
expect(cop.offenses.size).to eq(4)
end
end
end
context 'for method calls with parentheses' do
it 'accepts a method call without space' do
inspect_source(cop, ['something(x)',
'a.something(y, z)'])
expect(cop.offenses).to be_empty
end
it 'accepts a method call with space after the left parenthesis' do
inspect_source(cop, 'something( x )')
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/space_before_semicolon_spec.rb 0000664 0000000 0000000 00000003733 13070542236 0027513 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SpaceBeforeSemicolon do
subject(:cop) { described_class.new(config) }
let(:config) do
RuboCop::Config.new('Style/SpaceInsideBlockBraces' => brace_config)
end
let(:brace_config) { {} }
it 'registers an offense for space before semicolon' do
inspect_source(cop, 'x = 1 ; y = 2')
expect(cop.messages).to eq(
['Space found before semicolon.']
)
end
it 'does not register an offense for no space before semicolons' do
inspect_source(cop, 'x = 1; y = 2')
expect(cop.messages).to be_empty
end
it 'auto-corrects space before semicolon' do
new_source = autocorrect_source(cop, 'x = 1 ; y = 2')
expect(new_source).to eq('x = 1; y = 2')
end
it 'handles more than one space before a semicolon' do
new_source = autocorrect_source(cop, 'x = 1 ; y = 2')
expect(new_source).to eq('x = 1; y = 2')
end
context 'inside block braces' do
shared_examples 'common behavior' do
it 'accepts no space between an opening brace and a semicolon' do
inspect_source(cop, 'test {; }')
expect(cop.messages).to be_empty
end
end
context 'when EnforcedStyle for SpaceInsideBlockBraces is space' do
let(:brace_config) do
{ 'Enabled' => true, 'EnforcedStyle' => 'space' }
end
it_behaves_like 'common behavior'
it 'accepts a space between an opening brace and a semicolon' do
inspect_source(cop, 'test { ; }')
expect(cop.messages).to be_empty
end
end
context 'when EnforcedStyle for SpaceInsideBlockBraces is no_space' do
let(:brace_config) do
{ 'Enabled' => true, 'EnforcedStyle' => 'no_space' }
end
it_behaves_like 'common behavior'
it 'registers an offense for a space between an opening brace and a ' \
'semicolon' do
inspect_source(cop, 'test { ; }')
expect(cop.messages).to eq(['Space found before semicolon.'])
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/space_in_lambda_literal_spec.rb 0000664 0000000 0000000 00000012424 13070542236 0027620 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SpaceInLambdaLiteral, :config do
subject(:cop) { described_class.new(config) }
context 'when configured to enforce spaces' do
let(:cop_config) { { 'EnforcedStyle' => 'require_space' } }
it 'registers an offense for no space between -> and (' do
inspect_source(cop, 'a = ->(b, c) { b + c }')
expect(cop.offenses.size).to eq(1)
end
it 'does not register an offense for a space between -> and (' do
inspect_source(cop, 'a = -> (b, c) { b + c }')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for multi-line lambdas' do
inspect_source(cop, ['l = lambda do |a, b|',
' tmp = a * 7',
' tmp * b / 50',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense for no space between -> and {' do
inspect_source(cop, 'a = ->{ b + c }')
expect(cop.offenses).to be_empty
end
it 'registers an offense for no space in the inner nested lambda' do
inspect_source(cop, 'a = -> (b = ->(c) {}, d) { b + d }')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for no space in the outer nested lambda' do
inspect_source(cop, 'a = ->(b = -> (c) {}, d) { b + d }')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for no space in both lambdas when nested' do
inspect_source(cop, 'a = ->(b = ->(c) {}, d) { b + d }')
expect(cop.offenses.size).to eq(2)
end
it 'autocorrects an offense for no space between -> and (' do
code = 'a = ->(b, c) { b + c }'
expected = 'a = -> (b, c) { b + c }'
expect(autocorrect_source(cop, code)).to eq(expected)
end
it 'autocorrects an offense for no space in the inner nested lambda' do
code = 'a = -> (b = ->(c) {}, d) { b + d }'
expected = 'a = -> (b = -> (c) {}, d) { b + d }'
expect(autocorrect_source(cop, code)).to eq(expected)
end
it 'autocorrects an offense for no space in the outer nested lambda' do
code = 'a = ->(b = -> (c) {}, d) { b + d }'
expected = 'a = -> (b = -> (c) {}, d) { b + d }'
expect(autocorrect_source(cop, code)).to eq(expected)
end
it 'autocorrects an offense for no space in both lambdas when nested' do
code = 'a = ->(b = ->(c) {}, d) { b + d }'
expected = 'a = -> (b = -> (c) {}, d) { b + d }'
expect(autocorrect_source(cop, code)).to eq(expected)
end
end
context 'when configured to enforce no space' do
let(:cop_config) { { 'EnforcedStyle' => 'require_no_space' } }
it 'registers an offense for a space between -> and (' do
inspect_source(cop, 'a = -> (b, c) { b + c }')
expect(cop.offenses.size).to eq(1)
end
it 'does not register an offense for no space between -> and (' do
inspect_source(cop, 'a = ->(b, c) { b + c }')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for multi-line lambdas' do
inspect_source(cop, ['l = lambda do |a, b|',
' tmp = a * 7',
' tmp * b / 50',
'end'])
expect(cop.offenses).to be_empty
end
it 'does not register an offense for a space between -> and {' do
inspect_source(cop, 'a = -> { b + c }')
expect(cop.offenses).to be_empty
end
it 'registers an offense for spaces between -> and (' do
inspect_source(cop, 'a = -> (b, c) { b + c }')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for a space in the inner nested lambda' do
inspect_source(cop, 'a = ->(b = -> (c) {}, d) { b + d }')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for a space in the outer nested lambda' do
inspect_source(cop, 'a = -> (b = ->(c) {}, d) { b + d }')
expect(cop.offenses.size).to eq(1)
end
it 'registers two offenses for a space in both lambdas when nested' do
inspect_source(cop, 'a = -> (b = -> (c) {}, d) { b + d }')
expect(cop.offenses.size).to eq(2)
end
it 'autocorrects an offense for a space between -> and (' do
code = 'a = -> (b, c) { b + c }'
expected = 'a = ->(b, c) { b + c }'
expect(autocorrect_source(cop, code)).to eq(expected)
end
it 'autocorrects an offense for spaces between -> and (' do
code = 'a = -> (b, c) { b + c }'
expected = 'a = ->(b, c) { b + c }'
expect(autocorrect_source(cop, code)).to eq(expected)
end
it 'autocorrects an offense for a space in the inner nested lambda' do
code = 'a = ->(b = -> (c) {}, d) { b + d }'
expected = 'a = ->(b = ->(c) {}, d) { b + d }'
expect(autocorrect_source(cop, code)).to eq(expected)
end
it 'autocorrects an offense for a space in the outer nested lambda' do
code = 'a = -> (b = ->(c) {}, d) { b + d }'
expected = 'a = ->(b = ->(c) {}, d) { b + d }'
expect(autocorrect_source(cop, code)).to eq(expected)
end
it 'autocorrects two offenses for a space in both lambdas when nested' do
code = 'a = -> (b = -> (c) {}, d) { b + d }'
expected = 'a = ->(b = ->(c) {}, d) { b + d }'
expect(autocorrect_source(cop, code)).to eq(expected)
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/space_inside_array_percent_literal_spec.rb 0000664 0000000 0000000 00000005447 13070542236 0032112 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SpaceInsideArrayPercentLiteral do
subject(:cop) { described_class.new }
%w[i I w W].each do |type|
[%w[{ }], %w[( )], %w([ ]), %w[! !]].each do |(ldelim, rdelim)|
context "for #{type} type and #{[ldelim, rdelim]} delimiters" do
define_method(:code_example) do |content|
['%', type, ldelim, content, rdelim].join
end
def expect_corrected(source, expected)
expect(autocorrect_source(cop, source)).to eq expected
end
it 'registers an offense for unnecessary spaces' do
source = code_example('1 2')
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq([' '])
expect(cop.messages).to eq([described_class::MSG])
expect_corrected(source, code_example('1 2'))
end
it 'registers an offense for multiple spaces between items' do
source = code_example('1 2 3')
inspect_source(cop, source)
expect(cop.offenses.size).to eq(2)
expect_corrected(source, code_example('1 2 3'))
end
it 'accepts literals with escaped and additional spaces' do
source = code_example('a\ b \ c')
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect_corrected(source, code_example('a\ b \ c'))
end
it 'accepts literals without additional spaces' do
inspect_source(cop, code_example('a b c'))
expect(cop.messages).to be_empty
end
it 'accepts literals with escaped spaces' do
inspect_source(cop, code_example('a\ b\ \ c'))
expect(cop.messages).to be_empty
end
it 'accepts multi-line literals' do
inspect_source(cop, ["%#{type}(",
' a',
' b',
' c',
')'])
expect(cop.messages).to be_empty
end
it 'accepts multi-line literals within a method' do
inspect_source(cop, ['def foo',
" %#{type}(",
' a',
' b',
' c',
' )',
'end'])
expect(cop.messages).to be_empty
end
it 'accepts newlines and additional following alignment spaces' do
inspect_source(cop, ["%#{type}(a b",
' c)'])
expect(cop.messages).to be_empty
end
end
end
end
it 'accepts non array percent literals' do
inspect_source(cop, '%q( a b c )')
expect(cop.messages).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/space_inside_block_braces_spec.rb 0000664 0000000 0000000 00000027266 13070542236 0030154 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SpaceInsideBlockBraces, :config do
SUPPORTED_STYLES = %w[space no_space].freeze
subject(:cop) { described_class.new(config) }
let(:cop_config) do
{
'EnforcedStyle' => 'space',
'SupportedStyles' => SUPPORTED_STYLES,
'SpaceBeforeBlockParameters' => true
}
end
context 'with space inside empty braces not allowed' do
let(:cop_config) { { 'EnforcedStyleForEmptyBraces' => 'no_space' } }
it 'accepts empty braces with no space inside' do
inspect_source(cop, 'each {}')
expect(cop.offenses).to be_empty
end
it 'accepts braces with something inside' do
inspect_source(cop, 'each { "f" }')
expect(cop.offenses).to be_empty
end
it 'accepts multiline braces with content' do
inspect_source(cop, ['each { %(',
') }'])
expect(cop.offenses).to be_empty
end
it 'accepts empty braces with comment and line break inside' do
inspect_source(cop, [' each { # Comment',
' }'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for empty braces with line break inside' do
inspect_source(cop, [' each {',
' }'])
expect(cop.messages).to eq(['Space inside empty braces detected.'])
expect(cop.highlights).to eq(["\n "])
end
it 'registers an offense for empty braces with space inside' do
inspect_source(cop, 'each { }')
expect(cop.messages).to eq(['Space inside empty braces detected.'])
expect(cop.highlights).to eq([' '])
end
it 'auto-corrects unwanted space' do
new_source = autocorrect_source(cop, 'each { }')
expect(new_source).to eq('each {}')
end
it 'does not auto-correct when braces are not empty' do
old_source = <<-END
a {
b
}
END
new_source = autocorrect_source(cop, old_source)
expect(new_source).to eq(old_source)
end
end
context 'with space inside empty braces allowed' do
let(:cop_config) { { 'EnforcedStyleForEmptyBraces' => 'space' } }
it 'accepts empty braces with space inside' do
inspect_source(cop, 'each { }')
expect(cop.offenses).to be_empty
end
it 'registers an offense for empty braces with no space inside' do
inspect_source(cop, 'each {}')
expect(cop.messages).to eq(['Space missing inside empty braces.'])
expect(cop.highlights).to eq(['{}'])
end
it 'auto-corrects missing space' do
new_source = autocorrect_source(cop, 'each {}')
expect(new_source).to eq('each { }')
end
end
context 'with invalid value for EnforcedStyleForEmptyBraces' do
let(:cop_config) { { 'EnforcedStyleForEmptyBraces' => 'unknown' } }
it 'fails with an error' do
expect { inspect_source(cop, 'each { }') }
.to raise_error('Unknown EnforcedStyleForEmptyBraces selected!')
end
end
it 'accepts braces surrounded by spaces' do
inspect_source(cop, 'each { puts }')
expect(cop.offenses).to be_empty
end
it 'accepts left brace without outer space' do
inspect_source(cop, 'each{ puts }')
expect(cop.offenses).to be_empty
end
it 'registers an offense for left brace without inner space' do
inspect_source(cop, 'each {puts }')
expect(cop.messages).to eq(['Space missing inside {.'])
expect(cop.highlights).to eq(['p'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'registers an offense for right brace without inner space' do
inspect_source(cop, 'each { puts}')
expect(cop.messages).to eq(['Space missing inside }.'])
expect(cop.highlights).to eq(['}'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'registers offenses for both braces without inner space' do
inspect_source(cop, ['a {}',
'b { }',
'each {puts}'])
expect(cop.messages).to eq(['Space inside empty braces detected.',
'Space missing inside {.',
'Space missing inside }.'])
expect(cop.highlights).to eq([' ', 'p', '}'])
# Both correct and incorrect code has been found in relation to
# EnforcedStyleForEmptyBraces, but that doesn't matter. EnforcedStyle can
# be changed to get rid of the EnforcedStyle offenses.
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' =>
'no_space')
end
it 'auto-corrects missing space' do
new_source = autocorrect_source(cop, 'each {puts}')
expect(new_source).to eq('each { puts }')
end
context 'with passed in parameters' do
context 'for single-line blocks' do
it 'accepts left brace with inner space' do
inspect_source(cop, 'each { |x| puts }')
expect(cop.offenses).to be_empty
end
it 'registers an offense for left brace without inner space' do
inspect_source(cop, 'each {|x| puts }')
expect(cop.messages).to eq(['Space between { and | missing.'])
expect(cop.highlights).to eq(['{|'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
end
context 'for multi-line blocks' do
it 'accepts left brace with inner space' do
inspect_source(cop, ['each { |x|',
'puts',
'}'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for left brace without inner space' do
inspect_source(cop, ['each {|x|',
'puts',
'}'])
expect(cop.messages).to eq(['Space between { and | missing.'])
expect(cop.highlights).to eq(['{|'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'auto-corrects missing space' do
new_source = autocorrect_source(cop, <<-SOURCE)
each {|x|
puts
}
SOURCE
expect(new_source).to eq(<<-NEW_SOURCE)
each { |x|
puts
}
NEW_SOURCE
end
end
it 'accepts new lambda syntax' do
inspect_source(cop, '->(x) { x }')
expect(cop.offenses).to be_empty
end
it 'auto-corrects missing space' do
new_source = autocorrect_source(cop, 'each {|x| puts }')
expect(new_source).to eq('each { |x| puts }')
end
context 'and BlockDelimiters cop enabled' do
let(:config) do
RuboCop::Config.new('Style/BlockDelimiters' => { 'Enabled' => true },
'Style/SpaceInsideBlockBraces' => cop_config)
end
it 'does auto-correction for single-line blocks' do
new_source = autocorrect_source(cop, 'each {|x| puts}')
expect(new_source).to eq('each { |x| puts }')
end
it 'does auto-correction for multi-line blocks' do
old_source = ['each {|x|',
' puts',
'}']
new_source = autocorrect_source(cop, old_source)
expect(new_source).to eq(['each { |x|',
' puts',
'}'].join("\n"))
end
end
context 'and space before block parameters not allowed' do
let(:cop_config) do
{
'EnforcedStyle' => 'space',
'SupportedStyles' => SUPPORTED_STYLES,
'SpaceBeforeBlockParameters' => false
}
end
it 'registers an offense for left brace with inner space' do
inspect_source(cop, 'each { |x| puts }')
expect(cop.messages).to eq(['Space between { and | detected.'])
expect(cop.highlights).to eq([' '])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'accepts new lambda syntax' do
inspect_source(cop, '->(x) { x }')
expect(cop.offenses).to be_empty
end
it 'auto-corrects unwanted space' do
new_source = autocorrect_source(cop, 'each { |x| puts }')
expect(new_source).to eq('each {|x| puts }')
end
it 'accepts left brace without inner space' do
inspect_source(cop, 'each {|x| puts }')
expect(cop.offenses).to be_empty
end
end
end
context 'configured with no_space' do
let(:cop_config) do
{
'EnforcedStyle' => 'no_space',
'SupportedStyles' => SUPPORTED_STYLES,
'SpaceBeforeBlockParameters' => true
}
end
it 'accepts braces without spaces inside' do
inspect_source(cop, 'each {puts}')
expect(cop.offenses).to be_empty
end
it 'registers an offense for left brace with inner space' do
inspect_source(cop, 'each { puts}')
expect(cop.messages).to eq(['Space inside { detected.'])
expect(cop.highlights).to eq([' '])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'registers an offense for right brace with inner space' do
inspect_source(cop, 'each {puts }')
expect(cop.messages).to eq(['Space inside } detected.'])
expect(cop.highlights).to eq([' '])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'registers offenses for both braces with inner space' do
inspect_source(cop, 'each { puts }')
expect(cop.messages).to eq(['Space inside { detected.',
'Space inside } detected.'])
expect(cop.highlights).to eq([' ', ' '])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' =>
'space')
end
it 'accepts left brace without outer space' do
inspect_source(cop, 'each{puts}')
expect(cop.offenses).to be_empty
end
it 'auto-corrects unwanted space' do
new_source = autocorrect_source(cop, 'each{ puts }')
expect(new_source).to eq('each{puts}')
end
context 'with passed in parameters' do
context 'and space before block parameters allowed' do
it 'accepts left brace with inner space' do
inspect_source(cop, 'each { |x| puts}')
expect(cop.messages).to eq([])
expect(cop.highlights).to eq([])
end
it 'registers an offense for left brace without inner space' do
inspect_source(cop, 'each {|x| puts}')
expect(cop.messages).to eq(['Space between { and | missing.'])
expect(cop.highlights).to eq(['{|'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'accepts new lambda syntax' do
inspect_source(cop, '->(x) {x}')
expect(cop.offenses).to be_empty
end
it 'auto-corrects missing space' do
new_source = autocorrect_source(cop, 'each {|x| puts}')
expect(new_source).to eq('each { |x| puts}')
end
end
context 'and space before block parameters not allowed' do
let(:cop_config) do
{
'EnforcedStyle' => 'no_space',
'SupportedStyles' => SUPPORTED_STYLES,
'SpaceBeforeBlockParameters' => false
}
end
it 'registers an offense for left brace with inner space' do
inspect_source(cop, 'each { |x| puts}')
expect(cop.messages).to eq(['Space between { and | detected.'])
expect(cop.highlights).to eq([' '])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'accepts new lambda syntax' do
inspect_source(cop, '->(x) {x}')
expect(cop.offenses).to be_empty
end
it 'auto-corrects unwanted space' do
new_source = autocorrect_source(cop, 'each { |x| puts}')
expect(new_source).to eq('each {|x| puts}')
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/space_inside_brackets_spec.rb 0000664 0000000 0000000 00000005354 13070542236 0027333 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SpaceInsideBrackets do
subject(:cop) { described_class.new }
it 'registers an offense for an array literal with spaces inside' do
inspect_source(cop, ['a = [1, 2 ]',
'b = [ 1, 2]'])
expect(cop.messages).to eq(
['Space inside square brackets detected.',
'Space inside square brackets detected.']
)
end
it 'registers an offense for Hash#[] with symbol key and spaces inside' do
inspect_source(cop, ['a[ :key]',
'b[:key ]'])
expect(cop.messages).to eq(
['Space inside square brackets detected.',
'Space inside square brackets detected.']
)
end
it 'registers an offense for Hash#[] with string key and spaces inside' do
inspect_source(cop, ['a[\'key\' ]',
'b[ \'key\']'])
expect(cop.messages).to eq(
['Space inside square brackets detected.',
'Space inside square brackets detected.']
)
end
it 'accepts space inside strings within square brackets' do
inspect_source(cop, ["['Encoding:',",
" ' Enabled: false']"])
expect(cop.messages).to be_empty
end
it 'accepts space inside square brackets if on its own row' do
inspect_source(cop, ['a = [',
' 1, 2',
' ]'])
expect(cop.messages).to be_empty
end
it 'accepts space inside square brackets if with comment' do
inspect_source(cop, ['a = [ # Comment',
' 1, 2',
' ]'])
expect(cop.messages).to be_empty
end
it 'accepts square brackets as method name' do
inspect_source(cop, ['def Vector.[](*array)',
'end'])
expect(cop.messages).to be_empty
end
it 'accepts square brackets called with method call syntax' do
inspect_source(cop, 'subject.[](0)')
expect(cop.messages).to be_empty
end
it 'only reports a single space once' do
inspect_source(cop, '[ ]')
expect(cop.messages).to eq(
['Space inside square brackets detected.']
)
end
it 'auto-corrects unwanted space' do
new_source = autocorrect_source(cop, ['a = [1, 2 ]',
'b = [ 1, 2]',
'c[ :key]',
'd[:key ]',
'e["key" ]',
'f[ "key"]'])
expect(new_source).to eq(['a = [1, 2]',
'b = [1, 2]',
'c[:key]',
'd[:key]',
'e["key"]',
'f["key"]'].join("\n"))
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/space_inside_hash_literal_braces_spec.rb 0000664 0000000 0000000 00000016674 13070542236 0031522 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SpaceInsideHashLiteralBraces, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'EnforcedStyle' => 'space' } }
context 'with space inside empty braces not allowed' do
let(:cop_config) { { 'EnforcedStyleForEmptyBraces' => 'no_space' } }
it 'accepts empty braces with no space inside' do
inspect_source(cop, 'h = {}')
expect(cop.messages).to be_empty
end
it 'registers an offense for empty braces with space inside' do
inspect_source(cop, 'h = { }')
expect(cop.messages)
.to eq(['Space inside empty hash literal braces detected.'])
expect(cop.highlights).to eq([' '])
end
it 'auto-corrects unwanted space' do
new_source = autocorrect_source(cop, 'h = { }')
expect(new_source).to eq('h = {}')
end
end
context 'with space inside empty braces allowed' do
let(:cop_config) { { 'EnforcedStyleForEmptyBraces' => 'space' } }
it 'accepts empty braces with space inside' do
inspect_source(cop, 'h = { }')
expect(cop.messages).to be_empty
end
it 'registers an offense for empty braces with no space inside' do
inspect_source(cop, 'h = {}')
expect(cop.messages)
.to eq(['Space inside empty hash literal braces missing.'])
expect(cop.highlights).to eq(['{'])
end
it 'auto-corrects missing space' do
new_source = autocorrect_source(cop, 'h = {}')
expect(new_source).to eq('h = { }')
end
end
it 'registers an offense for hashes with no spaces if so configured' do
inspect_source(cop,
['h = {a: 1, b: 2}',
'h = {a => 1}'])
expect(cop.messages).to eq(['Space inside { missing.',
'Space inside } missing.',
'Space inside { missing.',
'Space inside } missing.'])
expect(cop.highlights).to eq(['{', '}', '{', '}'])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'no_space')
end
it 'registers an offense for correct + opposite' do
inspect_source(cop,
'h = { a: 1}')
expect(cop.messages).to eq(['Space inside } missing.'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'auto-corrects missing space' do
new_source = autocorrect_source(cop, ['h = {a: 1, b: 2}',
'h = {a => 1 }'])
expect(new_source).to eq(['h = { a: 1, b: 2 }',
'h = { a => 1 }'].join("\n"))
end
context 'when EnforcedStyle is no_space' do
let(:cop_config) { { 'EnforcedStyle' => 'no_space' } }
it 'registers an offense for hashes with spaces' do
inspect_source(cop,
'h = { a: 1, b: 2 }')
expect(cop.messages).to eq(['Space inside { detected.',
'Space inside } detected.'])
expect(cop.highlights).to eq([' ', ' '])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'space')
end
it 'registers an offense for opposite + correct' do
inspect_source(cop,
'h = {a: 1 }')
expect(cop.messages).to eq(['Space inside } detected.'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'auto-corrects unwanted space' do
new_source = autocorrect_source(cop, ['h = { a: 1, b: 2 }',
'h = {a => 1 }'])
expect(new_source).to eq(['h = {a: 1, b: 2}',
'h = {a => 1}'].join("\n"))
end
it 'accepts hashes with no spaces' do
inspect_source(cop,
['h = {a: 1, b: 2}',
'h = {a => 1}'])
expect(cop.offenses).to be_empty
end
it 'accepts multiline hash' do
inspect_source(cop,
['h = {',
' a: 1,',
' b: 2,',
'}'])
expect(cop.offenses).to be_empty
end
it 'accepts multiline hash with comment' do
inspect_source(cop,
['h = { # Comment',
' a: 1,',
' b: 2,',
'}'])
expect(cop.offenses).to be_empty
end
end
context 'when EnforcedStyle is compact' do
let(:cop_config) { { 'EnforcedStyle' => 'compact' } }
it "doesn't register an offense for non-nested hashes with spaces" do
inspect_source(cop, 'h = { a: 1, b: 2 }')
expect(cop.offenses).to be_empty
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'compact')
end
it 'registers an offense for nested hashes with spaces' do
inspect_source(cop, 'h = { a: { a: 1, b: 2 } }')
expect(cop.offenses.size).to eq 1
expect(cop.messages).to eq(['Space inside } detected.'])
end
it 'registers an offense for opposite + correct' do
inspect_source(cop,
'h = {a: 1 }')
expect(cop.messages).to eq(['Space inside { missing.'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'auto-corrects hashes with no space' do
new_source = autocorrect_source(cop, ['h = {a: 1, b: 2}',
'h = {a => 1 }'])
expect(new_source).to eq(['h = { a: 1, b: 2 }',
'h = { a => 1 }'].join("\n"))
end
it 'auto-corrects nested hashes with spaces' do
new_source = autocorrect_source(cop, ['h = { a: { a: 1, b: 2 } }',
'h = {a => method { 1 } }'])
expect(new_source).to eq(['h = { a: { a: 1, b: 2 }}',
'h = { a => method { 1 }}'].join("\n"))
end
it 'registers offenses for hashes with no spaces' do
inspect_source(cop,
['h = {a: 1, b: 2}',
'h = {a => 1}'])
expect(cop.offenses.size).to eq 4
end
it 'accepts multiline hash' do
inspect_source(cop,
['h = {',
' a: 1,',
' b: 2,',
'}'])
expect(cop.offenses).to be_empty
end
it 'accepts multiline hash with comment' do
inspect_source(cop,
['h = { # Comment',
' a: 1,',
' b: 2,',
'}'])
expect(cop.offenses).to be_empty
end
end
it 'accepts hashes with spaces by default' do
inspect_source(cop,
['h = { a: 1, b: 2 }',
'h = { a => 1 }'])
expect(cop.offenses).to be_empty
end
it 'accepts hash literals with no braces' do
inspect_source(cop, 'x(a: b.c)')
expect(cop.offenses).to be_empty
end
it 'can handle interpolation in a braceless hash literal' do
# A tricky special case where the closing brace of the
# interpolation risks getting confused for a hash literal brace.
inspect_source(cop, 'f(get: "#{x}")')
expect(cop.offenses).to be_empty
end
context 'on Hash[{ x: 1 } => [1]]' do
# regression test; see GH issue 2436
it 'does not register an offense' do
inspect_source(cop, 'Hash[{ x: 1 } => [1]]')
expect(cop.offenses).to be_empty
end
end
context 'on { key: "{" }' do
# regression test; see GH issue 3958
it 'does not register an offense' do
inspect_source(cop, '{ key: "{" }')
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/space_inside_parens_spec.rb 0000664 0000000 0000000 00000002363 13070542236 0027022 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SpaceInsideParens do
subject(:cop) { described_class.new }
it 'registers an offense for spaces inside parens' do
inspect_source(cop, ['f( 3)',
'g = (a + 3 )'])
expect(cop.messages).to eq(['Space inside parentheses detected.'] * 2)
end
it 'accepts parentheses in block parameter list' do
inspect_source(cop,
['list.inject(Tms.new) { |sum, (label, item)|',
'}'])
expect(cop.messages).to be_empty
end
it 'accepts parentheses with no spaces' do
inspect_source(cop, 'split("\n")')
expect(cop.messages).to be_empty
end
it 'accepts parentheses with line break' do
inspect_source(cop, ['f(',
' 1)'])
expect(cop.messages).to be_empty
end
it 'accepts parentheses with comment and line break' do
inspect_source(cop, ['f( # Comment',
' 1)'])
expect(cop.messages).to be_empty
end
it 'auto-corrects unwanted space' do
new_source = autocorrect_source(cop, ['f( 3)',
'g = ( a + 3 )'])
expect(new_source).to eq(['f(3)',
'g = (a + 3)'].join("\n"))
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/space_inside_percent_literal_delimiters_spec.rb 0000664 0000000 0000000 00000006413 13070542236 0033127 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SpaceInsidePercentLiteralDelimiters do
subject(:cop) { described_class.new }
%w[i I w W x].each do |type|
[%w[{ }], %w[( )], %w([ ]), %w[! !]].each do |(ldelim, rdelim)|
context "for #{type} type and #{[ldelim, rdelim]} delimiters" do
define_method(:code_example) do |content|
['%', type, ldelim, content, rdelim].join
end
def expect_corrected(source, expected)
expect(autocorrect_source(cop, source)).to eq expected
end
it 'registers an offense for unnecessary spaces' do
source = code_example(' 1 2 ')
inspect_source(cop, source)
expect(cop.offenses.size).to eq(2)
expect(cop.messages.uniq).to eq([described_class::MSG])
expect(cop.highlights).to eq([' ', ' '])
expect_corrected(source, code_example('1 2'))
end
it 'registers an offense for spaces after first delimiter' do
source = code_example(' 1 2')
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect_corrected(source, code_example('1 2'))
end
it 'registers an offense for spaces before final delimiter' do
source = code_example('1 2 ')
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect_corrected(source, code_example('1 2'))
end
it 'registers an offense for literals with escaped and other spaces' do
source = code_example(' \ a b c\ ')
inspect_source(cop, source)
expect(cop.offenses.size).to eq(2)
expect_corrected(source, code_example('\ a b c\ '))
end
it 'accepts literals without additional spaces' do
inspect_source(cop, code_example('a b c'))
expect(cop.messages).to be_empty
end
it 'accepts literals with escaped spaces' do
inspect_source(cop, code_example('\ a b c\ '))
expect(cop.messages).to be_empty
end
it 'accepts multi-line literals' do
inspect_source(cop, ["%#{type}(",
' a',
' b',
' c',
')'])
expect(cop.messages).to be_empty
end
it 'accepts multi-line literals within a method' do
inspect_source(cop, ['def foo',
" %#{type}(",
' a',
' b',
' c',
' )',
'end'])
expect(cop.messages).to be_empty
end
it 'accepts newlines and additional following alignment spaces' do
inspect_source(cop, ["%#{type}(a b",
' c)'])
expect(cop.messages).to be_empty
end
it 'accepts spaces between entries' do
inspect_source(cop, code_example('a b c'))
expect(cop.messages).to be_empty
end
end
end
end
it 'accepts other percent literals' do
%w[q r s].each do |type|
inspect_source(cop, "%#{type}( a b c )")
expect(cop.messages).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/space_inside_range_literal_spec.rb 0000664 0000000 0000000 00000003350 13070542236 0030337 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SpaceInsideRangeLiteral do
subject(:cop) { described_class.new }
it 'registers an offense for space inside .. literal' do
inspect_source(cop,
['1 .. 2',
'1.. 2',
'1 ..2'])
expect(cop.offenses.size).to eq(3)
expect(cop.messages)
.to eq(['Space inside range literal.'] * 3)
end
it 'accepts no space inside .. literal' do
inspect_source(cop, '1..2')
expect(cop.offenses).to be_empty
end
it 'registers an offense for space inside ... literal' do
inspect_source(cop,
['1 ... 2',
'1... 2',
'1 ...2'])
expect(cop.offenses.size).to eq(3)
expect(cop.messages)
.to eq(['Space inside range literal.'] * 3)
end
it 'accepts no space inside ... literal' do
inspect_source(cop, '1...2')
expect(cop.offenses).to be_empty
end
it 'accepts complex range literal with space in it' do
inspect_source(cop, '0...(line - 1)')
expect(cop.offenses).to be_empty
end
it 'accepts multiline range literal with no space in it' do
inspect_source(cop, ['x = 0..',
' 10'])
expect(cop.offenses).to be_empty
end
it 'registers an offense in multiline range literal with space in it' do
inspect_source(cop, ['x = 0 ..',
' 10'])
expect(cop.offenses.size).to eq(1)
end
it 'autocorrects space around .. literal' do
corrected = autocorrect_source(cop, ['1 .. 2'])
expect(corrected).to eq '1..2'
end
it 'autocorrects space around ... literal' do
corrected = autocorrect_source(cop, ['1 ... 2'])
expect(corrected).to eq '1...2'
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/space_inside_string_interpolation_spec.rb 0000664 0000000 0000000 00000006572 13070542236 0032015 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SpaceInsideStringInterpolation, :config do
subject(:cop) { described_class.new(config) }
let(:irregular_source) do
['"#{ var}"',
'"#{var }"',
'"#{ var }"',
'"#{var }"',
'"#{ var }"',
'"#{ var}"',
'"#{ var }"']
end
shared_examples 'ill-formatted string interpolations' do
let(:source_length) { source.class == String ? 1 : source.length }
it 'registers an offense for any irregular spacing inside the braces' do
inspect_source(cop, source)
expect(cop.messages).to eq([expected_message] * source_length)
end
it 'auto-corrects spacing within a string interpolation' do
new_source = autocorrect_source(cop, source)
expected_source = ([corrected_source] * source_length).join("\n")
expect(new_source).to eq(expected_source)
end
end
context 'when EnforcedStyle is no_space' do
let(:cop_config) { { 'EnforcedStyle' => 'no_space' } }
let(:expected_message) do
'Space inside string interpolation detected.'
end
context 'for always ill-formatted string interpolations' do
let(:source) { irregular_source }
let(:corrected_source) { '"#{var}"' }
it_behaves_like 'ill-formatted string interpolations'
end
context 'for "space" style formatted string interpolations' do
let(:source) { '"#{ var }"' }
let(:corrected_source) { '"#{var}"' }
it_behaves_like 'ill-formatted string interpolations'
end
context 'for well-formatted string interpolations' do
let(:source) do
['"Variable is #{var} "',
'" Variable is #{var}"']
end
it 'does not register an offense for excess literal spacing' do
inspect_source(cop, source)
expect(cop.messages).to be_empty
end
it 'does not correct valid string interpolations' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source.join("\n"))
end
end
it 'accepts empty interpolation' do
inspect_source(cop, '"#{}"')
expect(cop.messages).to be_empty
end
end
context 'when EnforcedStyle is space' do
let(:cop_config) { { 'EnforcedStyle' => 'space' } }
let(:expected_message) do
'Missing space around string interpolation detected.'
end
context 'for always ill-formatted string interpolations' do
let(:source) { irregular_source }
let(:corrected_source) { '"#{ var }"' }
it_behaves_like 'ill-formatted string interpolations'
end
context 'for "no_space" style formatted string interpolations' do
let(:source) { '"#{var}"' }
let(:corrected_source) { '"#{ var }"' }
it_behaves_like 'ill-formatted string interpolations'
end
context 'for well-formatted string interpolations' do
let(:source) do
['"Variable is #{ var } "',
'" Variable is #{ var }"']
end
it 'does not register an offense for excess literal spacing' do
inspect_source(cop, source)
expect(cop.messages).to be_empty
end
it 'does not correct valid string interpolations' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(source.join("\n"))
end
end
it 'accepts empty interpolation' do
inspect_source(cop, '"#{}"')
expect(cop.messages).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/special_global_vars_spec.rb 0000664 0000000 0000000 00000010635 13070542236 0027020 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SpecialGlobalVars, :config do
subject(:cop) { described_class.new(config) }
context 'when style is use_english_names' do
let(:cop_config) { { 'EnforcedStyle' => 'use_english_names' } }
it 'registers an offense for $:' do
inspect_source(cop, 'puts $:')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Prefer `$LOAD_PATH` over `$:`.'])
end
it 'registers an offense for $"' do
inspect_source(cop, 'puts $"')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Prefer `$LOADED_FEATURES` over `$"`.'])
end
it 'registers an offense for $0' do
inspect_source(cop, 'puts $0')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Prefer `$PROGRAM_NAME` over `$0`.'])
end
it 'registers an offense for $$' do
inspect_source(cop, 'puts $$')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Prefer `$PROCESS_ID` or `$PID` from the stdlib \'English\' ' \
'module (don\'t forget to require it) over `$$`.'])
end
it 'is clear about variables from the English library vs those not' do
inspect_source(cop, 'puts $*')
expect(cop.messages)
.to eq(['Prefer `$ARGV` from the stdlib \'English\' module ' \
'(don\'t forget to require it), or `ARGV` over `$*`.'])
end
it 'does not register an offense for backrefs like $1' do
inspect_source(cop, 'puts $1')
expect(cop.offenses).to be_empty
end
it 'auto-corrects $: to $LOAD_PATH' do
new_source = autocorrect_source(cop, '$:')
expect(new_source).to eq('$LOAD_PATH')
end
it 'auto-corrects $/ to $INPUT_RECORD_SEPARATOR' do
new_source = autocorrect_source(cop, '$/')
expect(new_source).to eq('$INPUT_RECORD_SEPARATOR')
end
it 'auto-corrects #$: to #{$LOAD_PATH}' do
new_source = autocorrect_source(cop, '"#$:"')
expect(new_source).to eq('"#{$LOAD_PATH}"')
end
it 'auto-corrects #{$!} to #{$ERROR_INFO}' do
new_source = autocorrect_source(cop, '"#{$!}"')
expect(new_source).to eq('"#{$ERROR_INFO}"')
end
it 'generates correct auto-config when Perl variable names are used' do
inspect_source(cop, '$0')
expect(cop.config_to_allow_offenses).to eq(
'EnforcedStyle' => 'use_perl_names'
)
end
it 'generates correct auto-config when mixed styles are used' do
inspect_source(cop, '$!; $ERROR_INFO')
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
end
context 'when style is use_perl_names' do
let(:cop_config) { { 'EnforcedStyle' => 'use_perl_names' } }
it 'registers an offense for $LOAD_PATH' do
inspect_source(cop, 'puts $LOAD_PATH')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Prefer `$:` over `$LOAD_PATH`.'])
end
it 'registers an offense for $LOADED_FEATURES' do
inspect_source(cop, 'puts $LOADED_FEATURES')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Prefer `$"` over `$LOADED_FEATURES`.'])
end
it 'registers an offense for $PROGRAM_NAME' do
inspect_source(cop, 'puts $PROGRAM_NAME')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Prefer `$0` over `$PROGRAM_NAME`.'])
end
it 'registers an offense for $PID' do
inspect_source(cop, 'puts $PID')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Prefer `$$` over `$PID`.'])
end
it 'registers an offense for $PROCESS_ID' do
inspect_source(cop, 'puts $PROCESS_ID')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Prefer `$$` over `$PROCESS_ID`.'])
end
it 'does not register an offense for backrefs like $1' do
inspect_source(cop, 'puts $1')
expect(cop.offenses).to be_empty
end
it 'auto-corrects $LOAD_PATH to $:' do
new_source = autocorrect_source(cop, '$LOAD_PATH')
expect(new_source).to eq('$:')
end
it 'auto-corrects $INPUT_RECORD_SEPARATOR to $/' do
new_source = autocorrect_source(cop, '$INPUT_RECORD_SEPARATOR')
expect(new_source).to eq('$/')
end
it 'auto-corrects #{$LOAD_PATH} to #$:' do
new_source = autocorrect_source(cop, '"#{$LOAD_PATH}"')
expect(new_source).to eq('"#$:"')
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/stabby_lambda_parentheses_spec.rb 0000664 0000000 0000000 00000003753 13070542236 0030215 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::StabbyLambdaParentheses, :config do
subject(:cop) { described_class.new(config) }
shared_examples 'common' do
it 'does not check the old lambda syntax' do
inspect_source(cop, 'lambda(&:nil?)')
expect(cop.offenses).to be_empty
end
it 'does not check a stabby lambda without arguments' do
inspect_source(cop, '-> { true }')
expect(cop.offenses).to be_empty
end
it 'does not check a method call named lambda' do
inspect_source(cop, 'o.lambda')
expect(cop.offenses).to be_empty
end
end
context 'require_parentheses' do
let(:cop_config) { { 'EnforcedStyle' => 'require_parentheses' } }
it_behaves_like 'common'
it 'registers an offense for a stabby lambda without parentheses' do
inspect_source(cop, '->a,b,c { a + b + c }')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Wrap stabby lambda arguments with parentheses.'])
end
it 'does not register an offense for a stabby lambda with parentheses' do
inspect_source(cop, '->(a,b,c) { a + b + c }')
expect(cop.offenses).to be_empty
end
it 'autocorrects when a stabby lambda has no parentheses' do
corrected = autocorrect_source(cop, ['->a,b,c { a + b + c }'])
expect(corrected).to eq '->(a,b,c) { a + b + c }'
end
end
context 'require_no_parentheses' do
let(:cop_config) { { 'EnforcedStyle' => 'require_no_parentheses' } }
it_behaves_like 'common'
it 'registers an offense for a stabby lambda with parentheses' do
inspect_source(cop, '->(a,b,c) { a + b + c }')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Do not wrap stabby lambda arguments with parentheses.'])
end
it 'autocorrects when a stabby lambda does not parentheses' do
corrected = autocorrect_source(cop, ['->(a,b,c) { a + b + c }'])
expect(corrected).to eq '->a,b,c { a + b + c }'
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/string_literals_in_interpolation_spec.rb 0000664 0000000 0000000 00000005522 13070542236 0031666 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::StringLiteralsInInterpolation, :config do
subject(:cop) { described_class.new(config) }
context 'configured with single quotes preferred' do
let(:cop_config) { { 'EnforcedStyle' => 'single_quotes' } }
it 'registers an offense for double quotes within embedded expression' do
src = '"#{"A"}"'
inspect_source(cop, src)
expect(cop.messages)
.to eq(['Prefer single-quoted strings inside interpolations.'])
end
it 'registers an offense for double quotes within embedded expression in ' \
'a heredoc string' do
src = ['< 'double_quotes' } }
it 'registers an offense for single quotes within embedded expression' do
src = %q("#{'A'}")
inspect_source(cop, src)
expect(cop.messages)
.to eq(['Prefer double-quoted strings inside interpolations.'])
end
it 'registers an offense for single quotes within embedded expression in ' \
'a heredoc string' do
src = ['< 'other' } }
it 'fails' do
expect { inspect_source(cop, 'a = "#{"b"}"') }
.to raise_error(RuntimeError)
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/string_literals_spec.rb 0000664 0000000 0000000 00000032527 13070542236 0026236 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::StringLiterals, :config do
subject(:cop) { described_class.new(config) }
context 'configured with single quotes preferred' do
let(:cop_config) { { 'EnforcedStyle' => 'single_quotes' } }
it 'registers offense for double quotes when single quotes suffice' do
inspect_source(cop, ['s = "abc"',
'x = "a\\\\b"',
'y ="\\\\b"',
'z = "a\\\\"'])
expect(cop.highlights).to eq(['"abc"',
'"a\\\\b"',
'"\\\\b"',
'"a\\\\"'])
expect(cop.messages)
.to eq(["Prefer single-quoted strings when you don't need " \
'string interpolation or special symbols.'] * 4)
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' =>
'double_quotes')
end
it 'registers offense for correct + opposite' do
inspect_source(cop, ['s = "abc"',
"x = 'abc'"])
expect(cop.messages)
.to eq(["Prefer single-quoted strings when you don't need " \
'string interpolation or special symbols.'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'accepts single quotes' do
inspect_source(cop, "a = 'x'")
expect(cop.offenses).to be_empty
end
it 'accepts single quotes in interpolation' do
inspect_source(cop, %q("hello#{hash['there']}"))
expect(cop.offenses).to be_empty
end
it 'accepts %q and %Q quotes' do
inspect_source(cop, 'a = %q(x) + %Q[x]')
expect(cop.offenses).to be_empty
end
it 'accepts % quotes' do
inspect_source(cop, 'a = %(x)')
expect(cop.offenses).to be_empty
end
it 'accepts heredocs' do
inspect_source(cop,
['execute <<-SQL',
' SELECT name from users',
'SQL'])
expect(cop.offenses).to be_empty
end
it 'accepts double quotes when new line is used' do
inspect_source(cop, '"\n"')
expect(cop.offenses).to be_empty
end
it 'accepts double quotes when interpolating & quotes in multiple lines' do
inspect_source(cop, '"#{encode_severity}:' \
'#{sprintf(\'%3d\', line_number)}: #{m}"')
expect(cop.offenses).to be_empty
end
it 'accepts double quotes when single quotes are used' do
inspect_source(cop, '"\'"')
expect(cop.offenses).to be_empty
end
it 'accepts double quotes when interpolating an instance variable' do
inspect_source(cop, '"#@test"')
expect(cop.offenses).to be_empty
end
it 'accepts double quotes when interpolating a global variable' do
inspect_source(cop, '"#$test"')
expect(cop.offenses).to be_empty
end
it 'accepts double quotes when interpolating a class variable' do
inspect_source(cop, '"#@@test"')
expect(cop.offenses).to be_empty
end
it 'accepts double quotes when control characters are used' do
inspect_source(cop, '"\e"')
expect(cop.offenses).to be_empty
end
it 'accepts double quotes when unicode control sequence is used' do
inspect_source(cop, '"Espa\u00f1a"')
expect(cop.offenses).to be_empty
end
it 'accepts double quotes at the start of regexp literals' do
inspect_source(cop, 's = /"((?:[^\\"]|\\.)*)"/')
expect(cop.offenses).to be_empty
end
it 'accepts double quotes with some other special symbols' do
# "Substitutions in double-quoted strings"
# http://www.ruby-doc.org/docs/ProgrammingRuby/html/language.html
src = ['g = "\xf9"',
'copyright = "\u00A9"']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'accepts " in a %w' do
inspect_source(cop, '%w(")')
expect(cop.offenses).to be_empty
end
it 'accepts \\\\\n in a string' do # this would be: "\\\n"
inspect_source(cop, '"foo \\\\\n bar"')
expect(cop.offenses).to be_empty
end
it 'accepts double quotes in interpolation' do
src = '"#{"A"}"'
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'detects unneeded double quotes within concatenated string' do
src = ['"#{x}" \\', '"y"']
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
end
it 'can handle a built-in constant parsed as string' do
# Parser will produce str nodes for constants such as __FILE__.
src = ['if __FILE__ == $PROGRAM_NAME',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'can handle character literals' do
src = 'a = ?/'
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'auto-corrects " with \'' do
new_source = autocorrect_source(cop, 's = "abc"')
expect(new_source).to eq("s = 'abc'")
end
it 'registers an offense for "\""' do
inspect_source(cop, '"\\""')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Prefer single-quoted strings when you ' \
"don't need string interpolation or " \
'special symbols.'])
end
it 'registers an offense for words with non-ascii chars' do
inspect_source(cop, '"España"')
expect(cop.offenses.size).to eq(1)
end
it 'autocorrects words with non-ascii chars' do
new_source = autocorrect_source(cop, '"España"')
expect(new_source).to eq("'España'")
end
it 'does not register an offense for words with non-ascii chars and ' \
'other control sequences' do
inspect_source(cop, '"España\n"')
expect(cop.offenses.size).to eq(0)
end
it 'does not autocorrect words with non-ascii chars and other control ' \
'sequences' do
new_source = autocorrect_source(cop, '"España\n"')
expect(new_source).to eq('"España\n"')
end
end
context 'configured with double quotes preferred' do
let(:cop_config) { { 'EnforcedStyle' => 'double_quotes' } }
it 'registers offense for single quotes when double quotes would ' \
'be equivalent' do
inspect_source(cop, "s = 'abc'")
expect(cop.highlights).to eq(["'abc'"])
expect(cop.messages)
.to eq(['Prefer double-quoted strings unless you need ' \
'single quotes to avoid extra backslashes for ' \
'escaping.'])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' =>
'single_quotes')
end
it 'registers offense for opposite + correct' do
inspect_source(cop, ['s = "abc"',
"x = 'abc'"])
expect(cop.messages)
.to eq(['Prefer double-quoted strings unless you need ' \
'single quotes to avoid extra backslashes for ' \
'escaping.'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'accepts double quotes' do
inspect_source(cop, 'a = "x"')
expect(cop.offenses).to be_empty
end
it 'accepts single quotes in interpolation' do
inspect_source(cop, %q("hello#{hash['there']}"))
expect(cop.offenses).to be_empty
end
it 'accepts %q and %Q quotes' do
inspect_source(cop, 'a = %q(x) + %Q[x]')
expect(cop.offenses).to be_empty
end
it 'accepts % quotes' do
inspect_source(cop, 'a = %(x)')
expect(cop.offenses).to be_empty
end
it 'accepts heredocs' do
inspect_source(cop,
['execute <<-SQL',
' SELECT name from users',
'SQL'])
expect(cop.offenses).to be_empty
end
it 'accepts single quotes when they are needed' do
src = ["a = '\\n'",
"b = '\"'",
"c = '\#{x}'"]
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it 'flags single quotes with plain # (not #@var or #{interpolation}' do
inspect_source(cop, "a = 'blah #'")
expect(cop.offenses.size).to be 1
end
it 'accepts single quotes at the start of regexp literals' do
inspect_source(cop, "s = /'((?:[^\\']|\\.)*)'/")
expect(cop.offenses).to be_empty
end
it "accepts ' in a %w" do
inspect_source(cop, "%w(')")
expect(cop.offenses).to be_empty
end
it 'can handle a built-in constant parsed as string' do
# Parser will produce str nodes for constants such as __FILE__.
src = ['if __FILE__ == $PROGRAM_NAME',
'end']
inspect_source(cop, src)
expect(cop.offenses).to be_empty
end
it "auto-corrects ' with \"" do
new_source = autocorrect_source(cop, "s = 'abc'")
expect(new_source).to eq('s = "abc"')
end
end
context 'when configured with a bad value' do
let(:cop_config) { { 'EnforcedStyle' => 'other' } }
it 'fails' do
expect { inspect_source(cop, 'a = "b"') }
.to raise_error(RuntimeError)
end
end
context 'when ConsistentQuotesInMultiline is true' do
context 'and EnforcedStyle is single_quotes' do
let(:cop_config) do
{
'ConsistentQuotesInMultiline' => true,
'EnforcedStyle' => 'single_quotes'
}
end
it 'registers an offense for strings with line breaks in them' do
inspect_source(cop,
['"--',
'SELECT *',
'LEFT JOIN X on Y',
'FROM Models"'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Prefer single-quoted strings when you ' \
"don't need string interpolation or " \
'special symbols.'])
end
it 'accepts continued strings using all single quotes' do
inspect_source(cop, ["'abc' \\",
"'def'"])
expect(cop.offenses).to be_empty
end
it 'registers an offense for mixed quote styles in a continued string' do
inspect_source(cop, ["'abc' \\",
'"def"'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Inconsistent quote style.'])
expect(cop.highlights).to eq(["'abc' \\\n\"def\""])
end
it 'registers an offense for unneeded double quotes in continuation' do
inspect_source(cop, ['"abc" \\',
'"def"'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Prefer single-quoted strings when you ' \
"don't need string interpolation or " \
'special symbols.'])
expect(cop.highlights).to eq(["\"abc\" \\\n\"def\""])
end
it "doesn't register offense for double quotes with interpolation" do
inspect_source(cop, ['"abc" \\',
'"def#{1}"'])
expect(cop.offenses).to be_empty
end
it "doesn't register offense for double quotes with embedded single" do
inspect_source(cop, ['"abc\'" \\',
'"def"'])
expect(cop.offenses).to be_empty
end
it 'accepts for double quotes with an escaped special character' do
inspect_source(cop, ['"abc\\t" \\',
'"def"'])
expect(cop.offenses).to be_empty
end
it 'accepts for double quotes with an escaped normal character' do
inspect_source(cop, ['"abc\\!" \\',
'"def"'])
expect(cop.offenses).to be_empty
end
it "doesn't choke on heredocs with inconsistent indentation" do
inspect_source(cop, ['<<-QUERY_STRING',
' DEFINE',
' BLAH',
'QUERY_STRING'])
expect(cop.offenses).to be_empty
end
end
context 'and EnforcedStyle is double_quotes' do
let(:cop_config) do
{
'ConsistentQuotesInMultiline' => true,
'EnforcedStyle' => 'double_quotes'
}
end
it 'accepts continued strings using all double quotes' do
inspect_source(cop, ['"abc" \\',
'"def"'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for mixed quote styles in a continued string' do
inspect_source(cop, ["'abc' \\",
'"def"'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Inconsistent quote style.'])
expect(cop.highlights).to eq(["'abc' \\\n\"def\""])
end
it 'registers an offense for unneeded single quotes in continuation' do
inspect_source(cop, ["'abc' \\",
"'def'"])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Prefer double-quoted strings unless you ' \
'need single quotes to avoid extra ' \
'backslashes for escaping.'])
expect(cop.highlights).to eq(["'abc' \\\n'def'"])
end
it "doesn't register offense for single quotes with embedded double" do
inspect_source(cop, ["'abc\"' \\",
"'def'"])
expect(cop.offenses).to be_empty
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/string_methods_spec.rb 0000664 0000000 0000000 00000001062 13070542236 0026050 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
RSpec.describe RuboCop::Cop::Style::StringMethods, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'intern' => 'to_sym' } }
let(:source) { "'something'.intern" }
let(:corrected) { autocorrect_source(cop, source) }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Prefer `to_sym` over `intern`.'])
expect(cop.highlights).to eq(%w[intern])
expect(corrected).to eq("'something'.to_sym")
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/struct_inheritance_spec.rb 0000664 0000000 0000000 00000002166 13070542236 0026722 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::StructInheritance do
subject(:cop) { described_class.new }
it 'registers an offense when extending instance of Struct' do
inspect_source(cop,
['class Person < Struct.new(:first_name, :last_name)',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense when extending instance of Struct with do ... end' do
inspect_source(cop,
['class Person < Struct.new(:first_name, :last_name) do end',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'accepts plain class' do
inspect_source(cop,
['class Person',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts extending DelegateClass' do
inspect_source(cop,
['class Person < DelegateClass(Animal)',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts assignment to Struct.new' do
inspect_source(cop, 'Person = Struct.new(:first_name, :last_name)')
expect(cop.offenses).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/symbol_array_spec.rb 0000664 0000000 0000000 00000006615 13070542236 0025533 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SymbolArray, :config do
subject(:cop) { described_class.new(config) }
let(:other_cops) do
{
'Style/PercentLiteralDelimiters' => {
'PreferredDelimiters' => {
'default' => '()'
}
}
}
end
context 'when EnforcedStyle is percent' do
let(:cop_config) { { 'EnforcedStyle' => 'percent' } }
it 'registers an offense for arrays of symbols' do
inspect_source(cop, '[:one, :two, :three]')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Use `%i` or `%I` for an array of symbols.'])
end
it 'autocorrects arrays of symbols' do
new_source = autocorrect_source(cop, '[:one, :two, :three]')
expect(new_source).to eq('%i(one two three)')
end
it 'autocorrects arrays of symbols with new line' do
new_source = autocorrect_source(cop, "[:one,\n:two, :three,\n:four]")
expect(new_source).to eq("%i(one \ntwo three \nfour)")
end
it 'uses %I when appropriate' do
new_source = autocorrect_source(cop, '[:"\\t", :"\\n", :three]')
expect(new_source).to eq('%I(\\t \\n three)')
end
it "doesn't break when a symbol contains )" do
source = '[:one, :")", :three, :"(", :"]", :"["]'
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('%i(one \\) three \\( ] [)')
end
it 'does not register an offense for array with non-syms' do
inspect_source(cop, '[:one, :two, "three"]')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for array starting with %i' do
inspect_source(cop, '%i(one two three)')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for array with one element' do
inspect_source(cop, '[:three]')
expect(cop.offenses).to be_empty
end
it 'does not register an offense if symbol contains whitespace' do
inspect_source(cop, '[:one, :two, :"space here"]')
expect(cop.offenses).to be_empty
end
context 'Ruby 1.9', :ruby19 do
it 'accepts arrays of smybols' do
inspect_source(cop, '[:one, :two, :three]')
expect(cop.offenses).to be_empty
end
end
context 'when PreferredDelimiters is specified' do
let(:other_cops) do
{
'Style/PercentLiteralDelimiters' => {
'PreferredDelimiters' => {
'default' => '[]'
}
}
}
end
it 'autocorrects an array with delimiters' do
source = '[:one, :")", :three, :"(", :"]", :"["]'
new_source = autocorrect_source(cop, source)
expect(new_source).to eq('%i[one ) three ( \\] \\[]')
end
end
end
context 'when EnforcedStyle is array' do
let(:cop_config) { { 'EnforcedStyle' => 'brackets' } }
it 'does not register an offense for arrays of symbols' do
inspect_source(cop, '[:one, :two, :three]')
expect(cop.offenses).to be_empty
end
it 'registers an offense for array starting with %i' do
inspect_source(cop, '%i(one two three)')
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Use `[]` for an array of symbols.'])
end
it 'autocorrects an array starting with %i' do
new_source = autocorrect_source(cop, '%i(one @two $three four-five)')
expect(new_source).to eq("[:one, :@two, :$three, :'four-five']")
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/symbol_literal_spec.rb 0000664 0000000 0000000 00000001664 13070542236 0026050 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SymbolLiteral do
subject(:cop) { described_class.new }
it 'registers an offense for word-line symbols using string syntax' do
inspect_source(cop, 'x = { :"test" => 0 }')
expect(cop.offenses.size).to eq(1)
end
it 'accepts string syntax when symbols have whitespaces in them' do
inspect_source(cop, 'x = { :"t o" => 0 }')
expect(cop.messages).to be_empty
end
it 'accepts string syntax when symbols have special chars in them' do
inspect_source(cop, 'x = { :"\tab" => 1 }')
expect(cop.messages).to be_empty
end
it 'accepts string syntax when symbol start with a digit' do
inspect_source(cop, 'x = { :"1" => 1 }')
expect(cop.messages).to be_empty
end
it 'auto-corrects by removing quotes' do
new_source = autocorrect_source(cop, '{ :"ala" => 1, :"bala" => 2 }')
expect(new_source).to eq('{ :ala => 1, :bala => 2 }')
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/symbol_proc_spec.rb 0000664 0000000 0000000 00000011610 13070542236 0025347 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::SymbolProc, :config do
subject(:cop) { described_class.new(config) }
let(:cop_config) { { 'IgnoredMethods' => %w[respond_to] } }
it 'registers an offense for a block with parameterless method call on ' \
'param' do
inspect_source(cop, 'coll.map { |e| e.upcase }')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Pass `&:upcase` as an argument to `map` instead of a block.'])
expect(cop.highlights).to eq(['{ |e| e.upcase }'])
end
it 'registers an offense for a block when method in body is unary -/=' do
inspect_source(cop, 'something.map { |x| -x }')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Pass `&:-@` as an argument to `map` instead of a block.'])
end
it 'accepts block with more than 1 arguments' do
inspect_source(cop, 'something { |x, y| x.method }')
expect(cop.offenses).to be_empty
end
it 'accepts lambda with 1 argument' do
inspect_source(cop, '->(x) { x.method }')
expect(cop.offenses).to be_empty
end
it 'accepts proc with 1 argument' do
inspect_source(cop, 'proc { |x| x.method }')
expect(cop.offenses).to be_empty
end
it 'accepts Proc.new with 1 argument' do
inspect_source(cop, 'Proc.new { |x| x.method }')
expect(cop.offenses).to be_empty
end
it 'accepts ignored method' do
inspect_source(cop, 'respond_to { |format| format.xml }')
expect(cop.offenses).to be_empty
end
it 'accepts block with no arguments' do
inspect_source(cop, 'something { x.method }')
expect(cop.offenses).to be_empty
end
it 'accepts empty block body' do
inspect_source(cop, 'something { |x| }')
expect(cop.offenses).to be_empty
end
it 'accepts block with more than 1 expression in body' do
inspect_source(cop, 'something { |x| x.method; something_else }')
expect(cop.offenses).to be_empty
end
it 'accepts block when method in body is not called on block arg' do
inspect_source(cop, 'something { |x| y.method }')
expect(cop.offenses).to be_empty
end
it 'accepts block with a block argument ' do
inspect_source(cop, 'something { |&x| x.call }')
expect(cop.offenses).to be_empty
end
it 'accepts block with splat params' do
inspect_source(cop, 'something { |*x| x.first }')
expect(cop.offenses).to be_empty
end
context 'when the method has arguments' do
let(:source) { 'method(one, 2) { |x| x.test }' }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages)
.to eq(['Pass `&:test` as an argument to `method` instead of a block.'])
end
it 'auto-corrects' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq 'method(one, 2, &:test)'
end
end
it 'autocorrects alias with symbols as proc' do
corrected = autocorrect_source(cop, ['coll.map { |s| s.upcase }'])
expect(corrected).to eq 'coll.map(&:upcase)'
end
it 'autocorrects multiple aliases with symbols as proc' do
corrected = autocorrect_source(cop, ['coll.map { |s| s.upcase }' \
'.map { |s| s.downcase }'])
expect(corrected).to eq 'coll.map(&:upcase).map(&:downcase)'
end
it 'auto-corrects correctly when there are no arguments in parentheses' do
corrected = autocorrect_source(cop, ['coll.map( ) { |s| s.upcase }'])
expect(corrected).to eq 'coll.map(&:upcase)'
end
it 'does not crash with a bare method call' do
run = -> { inspect_source(cop, 'coll.map { |s| bare_method }') }
expect(&run).not_to raise_error
end
context 'when `super` has arguments' do
let(:source) { 'super(one, two) { |x| x.test }' }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages)
.to eq(['Pass `&:test` as an argument to `super` instead of a block.'])
end
it 'auto-corrects' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq 'super(one, two, &:test)'
end
end
context 'when `super` has no arguments' do
let(:source) { 'super { |x| x.test }' }
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.messages)
.to eq(['Pass `&:test` as an argument to `super` instead of a block.'])
end
it 'auto-corrects' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq 'super(&:test)'
end
end
it 'auto-corrects correctly when args have a trailing comma' do
corrected = autocorrect_source(cop, ['mail(',
" to: 'foo',",
" subject: 'bar',",
') { |format| format.text }'])
expect(corrected).to eq(['mail(',
" to: 'foo',",
" subject: 'bar', &:text",
')'].join("\n"))
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/tab_spec.rb 0000664 0000000 0000000 00000003542 13070542236 0023572 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::Tab do
subject(:cop) { described_class.new }
it 'registers an offense for a line indented with tab' do
inspect_source(cop, "\tx = 0")
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for a line indented with multiple tabs' do
inspect_source(cop, "\t\t\tx = 0")
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for a line indented with mixed whitespace' do
inspect_source(cop, " \tx = 0")
expect(cop.offenses.size).to eq(1)
end
it 'registers offenses before __END__ but not after' do
inspect_source(cop, ["\tx = 0",
'__END__',
"\tx = 0"])
expect(cop.messages).to eq(['Tab detected.'])
end
it 'accepts a line with tab in a string' do
inspect_source(cop, "(x = \"\t\")")
expect(cop.offenses).to be_empty
end
it 'accepts a line which begins with tab in a string' do
inspect_source(cop, "x = '\n\thello'")
expect(cop.offenses).to be_empty
end
it 'accepts a line which begins with tab in a heredoc' do
inspect_source(cop, "x = < { 'Enabled' => redundant_parens_enabled }
}
end
shared_examples 'code with offense' do |code, expected|
context "when checking #{code}" do
let(:source) { code }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq([message])
end
if expected
it 'auto-corrects' do
expect(autocorrect_source(cop, code)).to eq(expected)
end
it 'claims to auto-correct' do
autocorrect_source(cop, code)
expect(cop.offenses.last.status).to eq(:corrected)
end
else
it 'does not auto-correct' do
expect(autocorrect_source(cop, code)).to eq(code)
end
it 'does not claim to auto-correct' do
autocorrect_source(cop, code)
expect(cop.offenses.last.status).to eq(:uncorrected)
end
end
end
end
shared_examples 'code without offense' do |code|
let(:source) { code }
it 'does not register an offense' do
expect(cop.offenses).to be_empty
end
end
shared_examples 'safe assignment disabled' do |style|
let(:cop_config) do
{
'EnforcedStyle' => style,
'AllowSafeAssignment' => false
}
end
it_behaves_like 'code with offense',
'foo = (bar = find_bar) ? a : b'
it_behaves_like 'code with offense',
'foo = bar = (baz = find_baz) ? a : b'
it_behaves_like 'code with offense',
'foo = (bar = baz = find_baz) ? a : b'
end
context 'when configured to enforce parentheses inclusion' do
let(:cop_config) { { 'EnforcedStyle' => 'require_parentheses' } }
let(:message) { 'Use parentheses for ternary conditions.' }
context 'with a simple condition' do
it_behaves_like 'code with offense',
'foo = bar? ? a : b',
'foo = (bar?) ? a : b'
it_behaves_like 'code with offense',
'foo = yield ? a : b',
'foo = (yield) ? a : b'
it_behaves_like 'code with offense',
'foo = bar[:baz] ? a : b',
'foo = (bar[:baz]) ? a : b'
end
context 'with a complex condition' do
it_behaves_like 'code with offense',
'foo = 1 + 1 == 2 ? a : b',
'foo = (1 + 1 == 2) ? a : b'
it_behaves_like 'code with offense',
'foo = bar && baz ? a : b',
'foo = (bar && baz) ? a : b'
it_behaves_like 'code with offense',
'foo = foo1 == foo2 ? a : b',
'foo = (foo1 == foo2) ? a : b'
it_behaves_like 'code with offense',
'foo = bar.baz? ? a : b',
'foo = (bar.baz?) ? a : b'
it_behaves_like 'code with offense',
'foo = bar && (baz || bar) ? a : b',
'foo = (bar && (baz || bar)) ? a : b'
end
context 'with an assignment condition' do
it_behaves_like 'code with offense',
'foo = bar = baz ? a : b',
'foo = bar = (baz) ? a : b'
it_behaves_like 'code with offense',
'foo = bar = baz = find_baz ? a : b',
'foo = bar = baz = (find_baz) ? a : b'
it_behaves_like 'code with offense',
'foo = bar = baz == 1 ? a : b',
'foo = bar = (baz == 1) ? a : b'
it_behaves_like 'code without offense',
'foo = (bar = baz = find_baz) ? a : b'
end
end
context 'when configured to enforce parentheses omission' do
let(:cop_config) { { 'EnforcedStyle' => 'require_no_parentheses' } }
let(:message) { 'Omit parentheses for ternary conditions.' }
context 'with a simple condition' do
it_behaves_like 'code with offense',
'foo = (bar?) ? a : b',
'foo = bar? ? a : b'
it_behaves_like 'code with offense',
'foo = (yield) ? a : b',
'foo = yield ? a : b'
it_behaves_like 'code with offense',
'foo = (bar[:baz]) ? a : b',
'foo = bar[:baz] ? a : b'
end
context 'with a complex condition' do
it_behaves_like 'code with offense',
'foo = (1 + 1 == 2) ? a : b',
'foo = 1 + 1 == 2 ? a : b'
it_behaves_like 'code with offense',
'foo = (foo1 == foo2) ? a : b'
it_behaves_like 'code with offense',
'foo = (bar && baz) ? a : b',
'foo = bar && baz ? a : b'
it_behaves_like 'code with offense',
'foo = (bar.baz?) ? a : b',
'foo = bar.baz? ? a : b'
it_behaves_like 'code without offense',
'foo = bar && (baz || bar) ? a : b'
end
context 'with an assignment condition' do
it_behaves_like 'code without offense',
'foo = (bar = find_bar) ? a : b'
it_behaves_like 'code without offense',
'foo = bar = (baz = find_baz) ? a : b'
it_behaves_like 'code with offense',
'foo = bar = (baz == 1) ? a : b',
'foo = bar = baz == 1 ? a : b'
it_behaves_like 'code without offense',
'foo = (bar = baz = find_baz) ? a : b'
it_behaves_like 'safe assignment disabled', 'require_no_parentheses'
end
context 'with an unparenthesized method call condition' do
it_behaves_like 'code with offense',
'foo = (defined? bar) ? a : b'
it_behaves_like 'code with offense',
'foo = (baz? bar) ? a : b'
context 'when calling method on a receiver' do
it_behaves_like 'code with offense',
'foo = (baz.foo? bar) ? a : b'
end
context 'when calling method on a literal receiver' do
it_behaves_like 'code with offense',
'foo = ("bar".foo? bar) ? a : b'
end
context 'when calling method on a constant receiver' do
it_behaves_like 'code with offense',
'foo = (Bar.foo? bar) ? a : b'
end
context 'when calling method with multiple arguments' do
it_behaves_like 'code with offense',
'foo = (baz.foo? bar, baz) ? a : b'
end
end
context 'with condition including a range' do
it_behaves_like 'code without offense',
'(foo..bar).include?(baz) ? a : b'
end
context 'with no space between the parentheses and question mark' do
it_behaves_like 'code with offense',
'(foo)? a : b',
'foo ? a : b'
end
end
context 'configured for parentheses on complex and there are parens' do
let(:cop_config) do
{ 'EnforcedStyle' => 'require_parentheses_when_complex' }
end
let(:message) do
'Only use parentheses for ternary expressions with complex conditions.'
end
context 'with a simple condition' do
it_behaves_like 'code with offense',
'foo = (bar?) ? a : b',
'foo = bar? ? a : b'
it_behaves_like 'code with offense',
'foo = (yield) ? a : b',
'foo = yield ? a : b'
it_behaves_like 'code with offense',
'foo = (bar[:baz]) ? a : b',
'foo = bar[:baz] ? a : b'
end
context 'with a complex condition' do
it_behaves_like 'code with offense',
'foo = (bar.baz?) ? a : b',
'foo = bar.baz? ? a : b'
it_behaves_like 'code without offense',
'foo = (bar && (baz || bar)) ? a : b'
end
context 'with an assignment condition' do
it_behaves_like 'code without offense',
'foo = (bar = find_bar) ? a : b'
it_behaves_like 'code without offense',
'foo = baz = (bar = find_bar) ? a : b'
it_behaves_like 'code without offense',
'foo = bar = (bar == 1) ? a : b'
it_behaves_like 'code without offense',
'foo = (bar = baz = find_bar) ? a : b'
it_behaves_like 'safe assignment disabled',
'require_parentheses_when_complex'
end
context 'with method call condition' do
it_behaves_like 'code with offense',
'foo = (defined? bar) ? a : b'
it_behaves_like 'code with offense',
'foo = (baz? bar) ? a : b'
context 'when calling method on a receiver' do
it_behaves_like 'code with offense',
'foo = (baz.foo? bar) ? a : b'
end
end
context 'with condition including a range' do
it_behaves_like 'code without offense',
'(foo..bar).include?(baz) ? a : b'
end
end
context 'configured for parentheses on complex and there are no parens' do
let(:cop_config) do
{ 'EnforcedStyle' => 'require_parentheses_when_complex' }
end
let(:message) do
'Use parentheses for ternary expressions with complex conditions.'
end
context 'with complex condition' do
it_behaves_like 'code with offense',
'foo = 1 + 1 == 2 ? a : b',
'foo = (1 + 1 == 2) ? a : b'
it_behaves_like 'code with offense',
'foo = bar && baz ? a : b',
'foo = (bar && baz) ? a : b'
it_behaves_like 'code with offense',
'foo = bar && baz || bar ? a : b',
'foo = (bar && baz || bar) ? a : b'
it_behaves_like 'code with offense',
'foo = bar && (baz != bar) ? a : b',
'foo = (bar && (baz != bar)) ? a : b'
it_behaves_like 'code with offense',
'foo = 1 < (bar.baz?) ? a : b',
'foo = (1 < (bar.baz?)) ? a : b'
it_behaves_like 'code with offense',
'foo = 1 <= (bar ** baz) ? a : b',
'foo = (1 <= (bar ** baz)) ? a : b'
it_behaves_like 'code with offense',
'foo = 1 >= bar * baz ? a : b',
'foo = (1 >= bar * baz) ? a : b'
it_behaves_like 'code with offense',
'foo = bar + baz ? a : b',
'foo = (bar + baz) ? a : b'
it_behaves_like 'code with offense',
'foo = bar - baz ? a : b',
'foo = (bar - baz) ? a : b'
it_behaves_like 'code with offense',
'foo = bar < baz ? a : b',
'foo = (bar < baz) ? a : b'
end
context 'with an assignment condition' do
it_behaves_like 'code with offense',
'foo = bar = baz == 1 ? a : b',
'foo = bar = (baz == 1) ? a : b'
it_behaves_like 'code without offense',
'foo = (bar = baz == 1) ? a : b'
end
end
context 'when `RedundantParenthesis` would cause an infinite loop' do
let(:redundant_parens_enabled) { true }
let(:cop_config) do
{
'EnforcedStyle' => 'require_parentheses',
'SupportedStyles' => %w[require_parentheses require_no_parentheses]
}
end
it_behaves_like 'code without offense',
'foo = bar? ? a : b'
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/trailing_blank_lines_spec.rb 0000664 0000000 0000000 00000010301 13070542236 0027165 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::TrailingBlankLines, :config do
subject(:cop) { described_class.new(config) }
context 'when EnforcedStyle is final_newline' do
let(:cop_config) { { 'EnforcedStyle' => 'final_newline' } }
it 'accepts final newline' do
inspect_source(cop, ['x = 0', ''])
expect(cop.offenses).to be_empty
end
it 'accepts an empty file' do
inspect_source(cop, '')
expect(cop.offenses).to be_empty
end
it 'accepts final blank lines if they come after __END__' do
inspect_source(cop, ['x = 0', '', '__END__', '', ''])
expect(cop.offenses).to be_empty
end
it 'accepts final blank lines if they come after __END__ in empty file' do
inspect_source(cop, ['__END__', '', '', ''])
expect(cop.offenses).to be_empty
end
it 'registers an offense for multiple trailing blank lines' do
inspect_source(cop, ['x = 0', '', '', '', ''])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['3 trailing blank lines detected.'])
end
it 'registers an offense for multiple blank lines in an empty file' do
inspect_source(cop, ['', '', '', '', ''])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['3 trailing blank lines detected.'])
end
it 'registers an offense for no final newline after assignment' do
inspect_source(cop, 'x = 0')
expect(cop.messages).to eq(['Final newline missing.'])
end
it 'registers an offense for no final newline after block comment' do
inspect_source(cop,
"puts 'testing rubocop when final new line is missing " \
"after block comments'\n\n=begin\nfirst line\nsecond " \
"line\nthird line\n=end")
expect(cop.messages).to eq(['Final newline missing.'])
end
it 'auto-corrects unwanted blank lines' do
new_source = autocorrect_source(cop, ['x = 0', '', '', '', ''])
expect(new_source).to eq(['x = 0', ''].join("\n"))
end
it 'auto-corrects unwanted blank lines in an empty file' do
new_source = autocorrect_source(cop, ['', '', '', '', ''])
expect(new_source).to eq(['', ''].join("\n"))
end
it 'auto-corrects even if some lines have space' do
new_source = autocorrect_source(cop, ['x = 0', '', ' ', '', ''])
expect(new_source).to eq(['x = 0', ''].join("\n"))
end
end
context 'when EnforcedStyle is final_blank_line' do
let(:cop_config) { { 'EnforcedStyle' => 'final_blank_line' } }
it 'registers an offense for final newline' do
inspect_source(cop, ['x = 0', ''])
expect(cop.messages).to eq(['Trailing blank line missing.'])
end
it 'registers an offense for multiple trailing blank lines' do
inspect_source(cop, ['x = 0', '', '', '', ''])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['3 trailing blank lines instead of 1 detected.'])
end
it 'registers an offense for multiple blank lines in an empty file' do
inspect_source(cop, ['', '', '', '', ''])
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['3 trailing blank lines instead of 1 detected.'])
end
it 'registers an offense for no final newline' do
inspect_source(cop, 'x = 0')
expect(cop.messages).to eq(['Final newline missing.'])
end
it 'accepts final blank line' do
inspect_source(cop, ['x = 0', '', ''])
expect(cop.offenses).to be_empty
end
it 'auto-corrects unwanted blank lines' do
new_source = autocorrect_source(cop, ['x = 0', '', '', '', ''])
expect(new_source).to eq(['x = 0', '', ''].join("\n"))
end
it 'auto-corrects unwanted blank lines in an empty file' do
new_source = autocorrect_source(cop, ['', '', '', '', ''])
expect(new_source).to eq(['', '', ''].join("\n"))
end
it 'auto-corrects missing blank line' do
new_source = autocorrect_source(cop, ['x = 0', ''])
expect(new_source).to eq(['x = 0', '', ''].join("\n"))
end
it 'auto-corrects missing newline' do
new_source = autocorrect_source(cop, ['x = 0'])
expect(new_source).to eq(['x = 0', '', ''].join("\n"))
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/trailing_comma_in_arguments_spec.rb 0000664 0000000 0000000 00000033023 13070542236 0030561 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::TrailingCommaInArguments, :config do
subject(:cop) { described_class.new(config) }
shared_examples 'single line lists' do |extra_info|
it 'registers an offense for trailing comma in a method call' do
inspect_source(cop, 'some_method(a, b, c, )')
expect(cop.messages)
.to eq(['Avoid comma after the last parameter of a method ' \
"call#{extra_info}."])
expect(cop.highlights).to eq([','])
end
it 'registers an offense for trailing comma in a method call with hash' \
' parameters at the end' do
inspect_source(cop, 'some_method(a, b, c: 0, d: 1, )')
expect(cop.messages)
.to eq(['Avoid comma after the last parameter of a method ' \
"call#{extra_info}."])
expect(cop.highlights).to eq([','])
end
it 'accepts method call without trailing comma' do
inspect_source(cop, 'some_method(a, b, c)')
expect(cop.offenses).to be_empty
end
it 'accepts method call without trailing comma with single element hash' \
' parameters at the end' do
inspect_source(cop, 'some_method(a: 1)')
expect(cop.offenses).to be_empty
end
it 'accepts method call without parameters' do
inspect_source(cop, 'some_method')
expect(cop.offenses).to be_empty
end
it 'accepts chained single-line method calls' do
inspect_source(cop, ['target',
' .some_method(a)'])
expect(cop.offenses).to be_empty
end
it 'auto-corrects unwanted comma in a method call' do
new_source = autocorrect_source(cop, 'some_method(a, b, c, )')
expect(new_source).to eq('some_method(a, b, c )')
end
it 'auto-corrects unwanted comma in a method call with hash parameters at' \
' the end' do
new_source = autocorrect_source(cop, 'some_method(a, b, c: 0, d: 1, )')
expect(new_source).to eq('some_method(a, b, c: 0, d: 1 )')
end
end
context 'with single line list of values' do
context 'when EnforcedStyleForMultiline is no_comma' do
let(:cop_config) { { 'EnforcedStyleForMultiline' => 'no_comma' } }
include_examples 'single line lists', ''
end
context 'when EnforcedStyleForMultiline is comma' do
let(:cop_config) { { 'EnforcedStyleForMultiline' => 'comma' } }
include_examples 'single line lists',
', unless each item is on its own line'
end
context 'when EnforcedStyleForMultiline is consistent_comma' do
let(:cop_config) { { 'EnforcedStyleForMultiline' => 'consistent_comma' } }
include_examples 'single line lists',
', unless items are split onto multiple lines'
end
end
context 'with multi-line list of values' do
context 'when EnforcedStyleForMultiline is no_comma' do
let(:cop_config) { { 'EnforcedStyleForMultiline' => 'no_comma' } }
it 'registers an offense for trailing comma in a method call with ' \
'hash parameters at the end' do
inspect_source(cop, ['some_method(',
' a,',
' b,',
' c: 0,',
' d: 1,)'])
expect(cop.highlights).to eq([','])
end
it 'accepts a method call with ' \
'hash parameters at the end and no trailing comma' do
inspect_source(cop, ['some_method(a,',
' b,',
' c: 0,',
' d: 1',
' )'])
expect(cop.offenses).to be_empty
end
it 'accepts comma inside a heredoc parameter at the end' do
inspect_source(cop, ['route(help: {',
" 'auth' => <<-HELP.chomp",
',',
'HELP',
'})'])
expect(cop.offenses).to be_empty
end
it 'auto-corrects unwanted comma in a method call with hash parameters' \
' at the end' do
new_source = autocorrect_source(cop, ['some_method(',
' a,',
' b,',
' c: 0,',
' d: 1,)'])
expect(new_source).to eq(['some_method(',
' a,',
' b,',
' c: 0,',
' d: 1)'].join("\n"))
end
end
context 'when EnforcedStyleForMultiline is comma' do
let(:cop_config) { { 'EnforcedStyleForMultiline' => 'comma' } }
context 'when closing bracket is on same line as last value' do
it 'accepts a method call with Hash as last parameter split on ' \
'multiple lines' do
inspect_source(cop, ['some_method(a: "b",',
' c: "d")'])
expect(cop.offenses).to be_empty
end
end
it 'registers an offense for no trailing comma in a method call with' \
' hash parameters at the end' do
inspect_source(cop, ['some_method(',
' a,',
' b,',
' c: 0,',
' d: 1',
' )'])
expect(cop.messages)
.to eq(['Put a comma after the last parameter of a multiline ' \
'method call.'])
expect(cop.highlights).to eq(['d: 1'])
end
it 'accepts a method call with two parameters on the same line' do
inspect_source(cop, ['some_method(a, b',
' )'])
expect(cop.offenses).to be_empty
end
it 'accepts trailing comma in a method call with hash' \
' parameters at the end' do
inspect_source(cop, ['some_method(',
' a,',
' b,',
' c: 0,',
' d: 1,',
' )'])
expect(cop.offenses).to be_empty
end
it 'accepts no trailing comma in a method call with a multiline' \
' braceless hash at the end with more than one parameter on a line' do
inspect_source(cop, ['some_method(',
' a,',
' b: 0,',
' c: 0, d: 1',
' )'])
expect(cop.offenses).to be_empty
end
it 'accepts a trailing comma in a method call with single ' \
'line hashes' do
inspect_source(cop, ['some_method(',
' { a: 0, b: 1 },',
' { a: 1, b: 0 },',
')'])
expect(cop.offenses).to be_empty
end
it 'accepts an empty hash being passed as a method argument' do
inspect_source(cop, 'Foo.new({})')
inspect_source(cop, ['Foo.new({',
' })'])
inspect_source(cop, ['Foo.new([',
' ])'])
expect(cop.offenses).to be_empty
end
it 'auto-corrects missing comma in a method call with hash parameters' \
' at the end' do
new_source = autocorrect_source(cop, ['some_method(',
' a,',
' b,',
' c: 0,',
' d: 1',
' )'])
expect(new_source).to eq(['some_method(',
' a,',
' b,',
' c: 0,',
' d: 1,',
' )'].join("\n"))
end
it 'accepts a multiline call with a single argument and trailing comma' do
inspect_source(cop, ['method(',
' 1,',
')'])
expect(cop.offenses).to be_empty
end
end
context 'when EnforcedStyleForMultiline is consistent_comma' do
let(:cop_config) { { 'EnforcedStyleForMultiline' => 'consistent_comma' } }
context 'when closing bracket is on same line as last value' do
it 'registers an offense for a method call, with a Hash as the ' \
'last parameter, split on multiple lines' do
inspect_source(cop, ['some_method(a: "b",',
' c: "d")'])
expect(cop.messages)
.to eq(['Put a comma after the last parameter of a ' \
'multiline method call.'])
end
end
it 'registers an offense for no trailing comma in a method call with' \
' hash parameters at the end' do
inspect_source(cop, ['some_method(',
' a,',
' b,',
' c: 0,',
' d: 1',
' )'])
expect(cop.messages)
.to eq(['Put a comma after the last parameter of a multiline ' \
'method call.'])
expect(cop.highlights).to eq(['d: 1'])
end
it 'registers an offense for no trailing comma in a method call with' \
'two parameters on the same line' do
inspect_source(cop, ['some_method(a, b',
' )'])
expect(cop.messages)
.to eq(['Put a comma after the last parameter of a multiline ' \
'method call.'])
end
it 'accepts trailing comma in a method call with hash' \
' parameters at the end' do
inspect_source(cop, ['some_method(',
' a,',
' b,',
' c: 0,',
' d: 1,',
' )'])
expect(cop.offenses).to be_empty
end
it 'accepts a trailing comma in a method call with ' \
'a single hash parameter' do
inspect_source(cop, ['some_method(',
' a: 0,',
' b: 1,',
' )'])
expect(cop.offenses).to be_empty
end
it 'accepts a trailing comma in a method call with single ' \
'line hashes' do
inspect_source(cop, ['some_method(',
' { a: 0, b: 1 },',
' { a: 1, b: 0 },',
')'])
expect(cop.offenses).to be_empty
end
# this is a sad parse error
it 'accepts no trailing comma in a method call with a block' \
' parameter at the end' do
inspect_source(cop, ['some_method(',
' a,',
' b,',
' c: 0,',
' d: 1,',
' &block',
' )'])
expect(cop.offenses).to be_empty
end
it 'accepts missing comma after a heredoc' do
# A heredoc that's the last item in a literal or parameter list can not
# have a trailing comma. It's a syntax error.
inspect_source(cop, ['route(1, <<-HELP.chomp',
'...',
'HELP',
')'])
expect(cop.offenses).to be_empty
end
it 'auto-corrects missing comma in a method call with hash parameters' \
' at the end' do
new_source = autocorrect_source(cop, ['some_method(',
' a,',
' b,',
' c: 0,',
' d: 1',
' )'])
expect(new_source).to eq(['some_method(',
' a,',
' b,',
' c: 0,',
' d: 1,',
' )'].join("\n"))
end
it 'accepts a multiline call with a single argument and trailing comma' do
inspect_source(cop, ['method(',
' 1,',
')'])
expect(cop.offenses).to be_empty
end
it 'accepts a multiline call with arguments on a single line and' \
' trailing comma' do
inspect_source(cop, ['method(',
' 1, 2,',
')'])
expect(cop.offenses).to be_empty
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/trailing_comma_in_literal_spec.rb 0000664 0000000 0000000 00000044331 13070542236 0030214 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::TrailingCommaInLiteral, :config do
subject(:cop) { described_class.new(config) }
shared_examples 'single line lists' do |extra_info|
it 'registers an offense for trailing comma in an Array literal' do
inspect_source(cop, 'VALUES = [1001, 2020, 3333, ]')
expect(cop.messages)
.to eq(["Avoid comma after the last item of an array#{extra_info}."])
expect(cop.highlights).to eq([','])
end
it 'registers an offense for trailing comma in a Hash literal' do
inspect_source(cop, 'MAP = { a: 1001, b: 2020, c: 3333, }')
expect(cop.messages)
.to eq(["Avoid comma after the last item of a hash#{extra_info}."])
expect(cop.highlights).to eq([','])
end
it 'accepts Array literal without trailing comma' do
inspect_source(cop, 'VALUES = [1001, 2020, 3333]')
expect(cop.offenses).to be_empty
end
it 'accepts single element Array literal without trailing comma' do
inspect_source(cop, 'VALUES = [1001]')
expect(cop.offenses).to be_empty
end
it 'accepts empty Array literal' do
inspect_source(cop, 'VALUES = []')
expect(cop.offenses).to be_empty
end
it 'accepts rescue clause' do
# The list of rescued classes is an array.
inspect_source(cop, ['begin',
' do_something',
'rescue RuntimeError',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts Hash literal without trailing comma' do
inspect_source(cop, 'MAP = { a: 1001, b: 2020, c: 3333 }')
expect(cop.offenses).to be_empty
end
it 'accepts single element Hash literal without trailing comma' do
inspect_source(cop, 'MAP = { a: 10001 }')
expect(cop.offenses).to be_empty
end
it 'accepts empty Hash literal' do
inspect_source(cop, 'MAP = {}')
expect(cop.offenses).to be_empty
end
it 'auto-corrects unwanted comma in an Array literal' do
new_source = autocorrect_source(cop, 'VALUES = [1001, 2020, 3333, ]')
expect(new_source).to eq('VALUES = [1001, 2020, 3333 ]')
end
it 'auto-corrects unwanted comma in a Hash literal' do
new_source = autocorrect_source(cop,
'MAP = { a: 1001, b: 2020, c: 3333, }')
expect(new_source).to eq('MAP = { a: 1001, b: 2020, c: 3333 }')
end
end
context 'with single line list of values' do
context 'when EnforcedStyleForMultiline is no_comma' do
let(:cop_config) { { 'EnforcedStyleForMultiline' => 'no_comma' } }
include_examples 'single line lists', ''
end
context 'when EnforcedStyleForMultiline is comma' do
let(:cop_config) { { 'EnforcedStyleForMultiline' => 'comma' } }
include_examples 'single line lists',
', unless each item is on its own line'
end
context 'when EnforcedStyleForMultiline is consistent_comma' do
let(:cop_config) { { 'EnforcedStyleForMultiline' => 'consistent_comma' } }
include_examples 'single line lists',
', unless items are split onto multiple lines'
end
end
context 'with multi-line list of values' do
context 'when EnforcedStyleForMultiline is no_comma' do
let(:cop_config) { { 'EnforcedStyleForMultiline' => 'no_comma' } }
it 'registers an offense for trailing comma in an Array literal' do
inspect_source(cop, ['VALUES = [',
' 1001,',
' 2020,',
' 3333,',
' ]'])
expect(cop.highlights).to eq([','])
end
it 'registers an offense for trailing comma in a Hash literal' do
inspect_source(cop, ['MAP = { a: 1001,',
' b: 2020,',
' c: 3333,',
' }'])
expect(cop.highlights).to eq([','])
end
it 'accepts an Array literal with no trailing comma' do
inspect_source(cop, ['VALUES = [ 1001,',
' 2020,',
' 3333 ]'])
expect(cop.offenses).to be_empty
end
it 'accepts a Hash literal with no trailing comma' do
inspect_source(cop, ['MAP = {',
' a: 1001,',
' b: 2020,',
' c: 3333',
' }'])
expect(cop.offenses).to be_empty
end
it 'accepts comma inside a heredoc parameters at the end' do
inspect_source(cop, ['route(help: {',
" 'auth' => <<-HELP.chomp",
',',
'HELP',
'})'])
expect(cop.offenses).to be_empty
end
it 'accepts comma in comment after last value item' do
inspect_source(cop, ['{ ',
" foo: 'foo',",
" bar: 'bar'.delete(',')#,",
'}'])
expect(cop.offenses).to be_empty
end
it 'auto-corrects unwanted comma in an Array literal' do
new_source = autocorrect_source(cop, ['VALUES = [',
' 1001,',
' 2020,',
' 3333,',
' ]'])
expect(new_source).to eq(['VALUES = [',
' 1001,',
' 2020,',
' 3333',
' ]'].join("\n"))
end
it 'auto-corrects unwanted comma in a Hash literal' do
new_source = autocorrect_source(cop, ['MAP = { a: 1001,',
' b: 2020,',
' c: 3333,',
' }'])
expect(new_source).to eq(['MAP = { a: 1001,',
' b: 2020,',
' c: 3333',
' }'].join("\n"))
end
end
context 'when EnforcedStyleForMultiline is comma' do
let(:cop_config) { { 'EnforcedStyleForMultiline' => 'comma' } }
context 'when closing bracket is on same line as last value' do
it 'accepts Array literal with no trailing comma' do
inspect_source(cop, ['VALUES = [',
' 1001,',
' 2020,',
' 3333]'])
expect(cop.offenses).to be_empty
end
it 'accepts a Hash literal with no trailing comma' do
inspect_source(cop, ['VALUES = {',
' a: "b",',
' c: "d",',
' e: "f"}'])
expect(cop.offenses).to be_empty
end
end
it 'accepts Array literal with two of the values on the same line' do
inspect_source(cop, ['VALUES = [',
' 1001, 2020,',
' 3333',
' ]'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for an Array literal with two of the values ' \
'on the same line and a trailing comma' do
inspect_source(cop, ['VALUES = [',
' 1001, 2020,',
' 3333,',
' ]'])
expect(cop.messages)
.to eq(['Avoid comma after the last item of an array, unless each ' \
'item is on its own line.'])
end
it 'registers an offense for no trailing comma in a Hash literal' do
inspect_source(cop, ['MAP = { a: 1001,',
' b: 2020,',
' c: 3333',
'}'])
expect(cop.messages)
.to eq(['Put a comma after the last item of a multiline hash.'])
expect(cop.highlights).to eq(['c: 3333'])
end
it 'registers an offense for trailing comma in a comment in Hash' do
inspect_source(cop, ['MAP = { a: 1001,',
' b: 2020,',
' c: 3333 # ,',
'}'])
expect(cop.messages)
.to eq(['Put a comma after the last item of a multiline hash.'])
expect(cop.highlights).to eq(['c: 3333'])
end
it 'accepts trailing comma in an Array literal' do
inspect_source(cop, ['VALUES = [1001,',
' 2020,',
' 3333,',
' ]'])
expect(cop.offenses).to be_empty
end
it 'accepts trailing comma in a Hash literal' do
inspect_source(cop, ['MAP = {',
' a: 1001,',
' b: 2020,',
' c: 3333,',
' }'])
expect(cop.offenses).to be_empty
end
it 'accepts a multiline word array' do
inspect_source(cop, ['ingredients = %w(',
' sausage',
' anchovies',
' olives',
')'])
expect(cop.offenses).to be_empty
end
it 'accepts missing comma after a heredoc' do
# A heredoc that's the last item in a literal or parameter list can not
# have a trailing comma. It's a syntax error.
inspect_source(cop, ['route(help: {',
" 'auth' => <<-HELP.chomp",
'...',
'HELP',
'})'])
expect(cop.offenses).to be_empty
end
it 'accepts an empty hash being passed as a method argument' do
inspect_source(cop, 'Foo.new({})')
inspect_source(cop, ['Foo.new({',
' })'])
inspect_source(cop, ['Foo.new([',
' ])'])
expect(cop.offenses).to be_empty
end
it 'auto-corrects an Array literal with two of the values on the same' \
' line and a trailing comma' do
new_source = autocorrect_source(cop, ['VALUES = [',
' 1001, 2020,',
' 3333',
' ]'])
expect(new_source).to eq(['VALUES = [',
' 1001, 2020,',
' 3333',
' ]'].join("\n"))
end
it 'auto-corrects missing comma in a Hash literal' do
new_source = autocorrect_source(cop, ['MAP = { a: 1001,',
' b: 2020,',
' c: 3333',
'}'])
expect(new_source).to eq(['MAP = { a: 1001,',
' b: 2020,',
' c: 3333,',
'}'].join("\n"))
end
it 'accepts a multiline array with a single item and trailing comma' do
inspect_source(cop, ['foo = [',
' 1,',
']'])
expect(cop.offenses).to be_empty
end
it 'accepts a multiline hash with a single pair and trailing comma' do
inspect_source(cop, ['bar = {',
' a: 123,',
'}'])
expect(cop.offenses).to be_empty
end
end
context 'when EnforcedStyleForMultiline is consistent_comma' do
let(:cop_config) { { 'EnforcedStyleForMultiline' => 'consistent_comma' } }
context 'when closing bracket is on same line as last value' do
it 'registers an offense for an Array literal with no trailing comma' do
inspect_source(cop, ['VALUES = [',
' 1001,',
' 2020,',
' 3333]'])
expect(cop.messages)
.to eq(['Put a comma after the last item of a multiline array.'])
end
it 'registers an offense for a Hash literal with no trailing comma' do
inspect_source(cop, ['VALUES = {',
' a: "b",',
' b: "c",',
' d: "e"}'])
expect(cop.messages)
.to eq(['Put a comma after the last item of a multiline hash.'])
end
it 'auto-corrects a missing comma in a Hash literal' do
new_source = autocorrect_source(cop, ['MAP = { a: 1001,',
' b: 2020,',
' c: 3333}'])
expect(new_source).to eq(['MAP = { a: 1001,',
' b: 2020,',
' c: 3333,}'].join("\n"))
end
end
it 'accepts Array literal with two of the values on the same line' do
inspect_source(cop, ['VALUES = [',
' 1001, 2020,',
' 3333,',
' ]'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for an Array literal with two of the values ' \
'on the same line and no trailing comma' do
inspect_source(cop, ['VALUES = [',
' 1001, 2020,',
' 3333',
' ]'])
expect(cop.messages)
.to eq(['Put a comma after the last item of a multiline array.'])
end
it 'registers an offense for no trailing comma in a Hash literal' do
inspect_source(cop, ['MAP = { a: 1001,',
' b: 2020,',
' c: 3333',
'}'])
expect(cop.messages)
.to eq(['Put a comma after the last item of a multiline hash.'])
expect(cop.highlights).to eq(['c: 3333'])
end
it 'accepts trailing comma in an Array literal' do
inspect_source(cop, ['VALUES = [1001,',
' 2020,',
' 3333,',
' ]'])
expect(cop.offenses).to be_empty
end
it 'accepts trailing comma in a Hash literal' do
inspect_source(cop, ['MAP = {',
' a: 1001,',
' b: 2020,',
' c: 3333,',
' }'])
expect(cop.offenses).to be_empty
end
it 'accepts a multiline word array' do
inspect_source(cop, ['ingredients = %w(',
' sausage',
' anchovies',
' olives',
')'])
expect(cop.offenses).to be_empty
end
it 'accepts missing comma after a heredoc' do
# A heredoc that's the last item in a literal or parameter list can not
# have a trailing comma. It's a syntax error.
inspect_source(cop, ['route(help: {',
" 'auth' => <<-HELP.chomp",
'...',
'HELP',
'})'])
expect(cop.offenses).to be_empty
end
it 'auto-corrects an Array literal with two of the values on the same' \
' line and a trailing comma' do
new_source = autocorrect_source(cop, ['VALUES = [',
' 1001, 2020,',
' 3333',
' ]'])
expect(new_source).to eq(['VALUES = [',
' 1001, 2020,',
' 3333,',
' ]'].join("\n"))
end
it 'auto-corrects missing comma in a Hash literal' do
new_source = autocorrect_source(cop, ['MAP = { a: 1001,',
' b: 2020,',
' c: 3333',
'}'])
expect(new_source).to eq(['MAP = { a: 1001,',
' b: 2020,',
' c: 3333,',
'}'].join("\n"))
end
it 'accepts a multiline array with a single item and trailing comma' do
inspect_source(cop, ['foo = [',
' 1,',
']'])
expect(cop.offenses).to be_empty
end
it 'accepts a multiline hash with a single pair and trailing comma' do
inspect_source(cop, ['bar = {',
' a: 123,',
'}'])
expect(cop.offenses).to be_empty
end
it 'accepts a multiline array with items on a single line and' \
'trailing comma' do
inspect_source(cop, ['foo = [',
' 1, 2,',
']'])
expect(cop.offenses).to be_empty
end
it 'accepts a multiline hash with pairs on a single line and' \
'trailing comma' do
inspect_source(cop, ['bar = {',
' a: 1001, b: 2020,',
'}'])
expect(cop.offenses).to be_empty
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/trailing_underscore_variable_spec.rb 0000664 0000000 0000000 00000022744 13070542236 0030740 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::TrailingUnderscoreVariable do
subject(:cop) { described_class.new(config) }
shared_examples 'common functionality' do
it 'registers an offense when the last variable of parallel assignment ' \
'is an underscore' do
inspect_source(cop, 'a, b, _ = foo()')
expect(cop.messages)
.to eq(['Do not use trailing `_`s in parallel assignment. ' \
'Prefer `a, b, = foo()`.'])
end
it 'registers an offense when multiple underscores are used '\
'as the last variables of parallel assignment ' do
inspect_source(cop, 'a, _, _ = foo()')
expect(cop.messages)
.to eq(['Do not use trailing `_`s in parallel assignment. ' \
'Prefer `a, = foo()`.'])
end
it 'registers an offense for splat underscore as the last variable' do
inspect_source(cop, 'a, *_ = foo()')
expect(cop.messages)
.to eq(['Do not use trailing `_`s in parallel assignment. ' \
'Prefer `a, = foo()`.'])
end
it 'registers an offense when underscore is the second to last variable ' \
'and blank is the last variable' do
inspect_source(cop, 'a, _, = foo()')
expect(cop.messages)
.to eq(['Do not use trailing `_`s in parallel assignment. ' \
'Prefer `a, = foo()`.'])
end
it 'registers an offense when underscore is the only variable ' \
'in parallel assignment' do
inspect_source(cop, '_, = foo()')
expect(cop.messages)
.to eq(['Do not use trailing `_`s in parallel assignment. ' \
'Prefer `foo()`.'])
end
it 'registers an offense for an underscore as the last param ' \
'when there is also an underscore as the first param' do
inspect_source(cop, '_, b, _ = foo()')
expect(cop.messages)
.to eq(['Do not use trailing `_`s in parallel assignment. ' \
'Prefer `_, b, = foo()`.'])
end
it 'does not register an offense when there are no underscores' do
inspect_source(cop, 'a, b, c = foo()')
expect(cop.messages).to be_empty
end
it 'does not register an offense for underscores at the beginning' do
inspect_source(cop, '_, a, b = foo()')
expect(cop.messages).to be_empty
end
it 'does not register an offense for an underscore preceded by a ' \
'splat variable anywhere in the argument chain' do
inspect_source(cop, '*a, b, _ = foo()')
expect(cop.messages).to be_empty
end
it 'does not register an offense for an underscore preceded by a ' \
'splat variable' do
inspect_source(cop, 'a, *b, _ = foo()')
expect(cop.messages).to be_empty
end
it 'does not register an offense for an underscore preceded by a ' \
'splat variable and another underscore' do
inspect_source(cop, '_, *b, _ = *foo')
expect(cop.messages).to be_empty
end
it 'does not register an offense for multiple underscores preceded by a ' \
'splat variable' do
inspect_source(cop, 'a, *b, _, _ = foo()')
expect(cop.messages).to be_empty
end
it 'does not register an offense for multiple named underscores ' \
'preceded by a splat variable' do
inspect_source(cop, 'a, *b, _c, _d = foo()')
expect(cop.messages).to be_empty
end
it 'registers an offense for multiple underscore variables preceded by ' \
'a splat underscore variable' do
inspect_source(cop, 'a, *_, _, _ = foo()')
expect(cop.messages)
.to eq(['Do not use trailing `_`s in parallel assignment. ' \
'Prefer `a, = foo()`.'])
end
it 'does not register an offense for a named underscore variable ' \
'preceded by a splat variable' do
inspect_source(cop, 'a, *b, _c = foo()')
expect(cop.messages).to be_empty
end
it 'does not register an offense for a named variable preceded by a ' \
'names splat underscore variable' do
inspect_source(cop, 'a, *b, _c = foo()')
expect(cop.messages).to be_empty
end
describe 'autocorrect' do
it 'removes trailing underscores automatically' do
new_source = autocorrect_source(cop, 'a, b, _ = foo()')
expect(new_source).to eq('a, b, = foo()')
end
it 'removes trailing underscores and commas' do
new_source = autocorrect_source(cop, 'a, b, _, = foo()')
expect(new_source).to eq('a, b, = foo()')
end
it 'removes multiple trailing underscores' do
new_source = autocorrect_source(cop, 'a, _, _ = foo()')
expect(new_source).to eq('a, = foo()')
end
it 'removes trailing underscores and commas and preserves assignments' do
new_source = autocorrect_source(cop, 'a, _, _, = foo()')
expect(new_source).to eq('a, = foo()')
end
it 'removes trailing comma when it is the only variable' do
new_source = autocorrect_source(cop, '_, = foo()')
expect(new_source).to eq('foo()')
end
it 'removes all assignments when every assignment is to `_`' do
new_source = autocorrect_source(cop, '_, _, _, = foo()')
expect(new_source).to eq('foo()')
end
it 'remove splat underscore' do
new_source = autocorrect_source(cop, 'a, *_ = foo()')
expect(new_source).to eq('a, = foo()')
end
end
end
context 'configured to allow named underscore variables' do
include_examples 'common functionality'
let(:config) do
RuboCop::Config.new('Style/TrailingUnderscoreVariable' => {
'Enabled' => true,
'AllowNamedUnderscoreVariables' => true
})
end
it 'does not register an offense for an underscore variable preceded ' \
'by a named splat underscore variable' do
inspect_source(cop, 'a, *_b, _ = foo()')
expect(cop.messages).to be_empty
end
it 'does not register an offense for named variables ' \
'that start with an underscore' do
inspect_source(cop, 'a, b, _c = foo()')
expect(cop.messages).to be_empty
end
it 'does not register an offense for a named splat underscore ' \
'as the last variable' do
inspect_source(cop, 'a, *_b = foo()')
expect(cop.messages).to be_empty
end
it 'does not register an offense for an underscore preceded by ' \
'a named splat underscore' do
inspect_source(cop, 'a, *_b, _ = foo()')
expect(cop.messages).to be_empty
end
it 'does not register an offense for multiple underscore variables ' \
'preceded by a named splat underscore variable' do
inspect_source(cop, 'a, *_b, _, _ = foo()')
expect(cop.messages).to be_empty
end
end
context 'configured to not allow named underscore variables' do
include_examples 'common functionality'
let(:config) do
RuboCop::Config.new('Style/TrailingUnderscoreVariable' => {
'Enabled' => true,
'AllowNamedUnderscoreVariables' => false
})
end
it 'registers an offense for named variables ' \
'that start with an underscore' do
inspect_source(cop, 'a, b, _c = foo()')
expect(cop.messages)
.to eq(['Do not use trailing `_`s in parallel assignment. ' \
'Prefer `a, b, = foo()`.'])
end
it 'registers an offense for a named splat underscore ' \
'as the last variable' do
inspect_source(cop, 'a, *_b = foo()')
expect(cop.messages)
.to eq(['Do not use trailing `_`s in parallel assignment. ' \
'Prefer `a, = foo()`.'])
end
it 'does not register an offense for a named underscore preceded by a ' \
'splat variable' do
inspect_source(cop, 'a, *b, _c = foo()')
expect(cop.messages).to be_empty
end
it 'registers an offense for an underscore variable preceded ' \
'by a named splat underscore variable' do
inspect_source(cop, 'a, *_b, _ = foo()')
expect(cop.messages)
.to eq(['Do not use trailing `_`s in parallel assignment. ' \
'Prefer `a, = foo()`.'])
end
it 'registers an offense for an underscore preceded by ' \
'a named splat underscore' do
inspect_source(cop, 'a, b, *_c, _ = foo()')
expect(cop.messages)
.to eq(['Do not use trailing `_`s in parallel assignment. ' \
'Prefer `a, b, = foo()`.'])
end
it 'registers an offense for multiple underscore variables ' \
'preceded by a named splat underscore variable' do
inspect_source(cop, 'a, *_b, _, _ = foo()')
expect(cop.messages)
.to eq(['Do not use trailing `_`s in parallel assignment. ' \
'Prefer `a, = foo()`.'])
end
context 'autocorrect' do
it 'removes named underscore variables' do
new_source = autocorrect_source(cop, 'a, _b = foo()')
expect(new_source).to eq('a, = foo()')
end
it 'removes named splat underscore variables' do
new_source = autocorrect_source(cop, 'a, *_b = foo()')
expect(new_source).to eq('a, = foo()')
end
it 'removes named splat underscore and named underscore variables' do
new_source = autocorrect_source(cop, 'a, *_b, _c = foo()')
expect(new_source).to eq('a, = foo()')
end
it 'works when last underscore is followed by a comma' do
new_source = autocorrect_source(cop, 'a, _, = foo()')
expect(new_source).to eq('a, = foo()')
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/trailing_whitespace_spec.rb 0000664 0000000 0000000 00000004562 13070542236 0027054 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::TrailingWhitespace do
subject(:cop) { described_class.new }
it 'registers an offense for a line ending with space' do
inspect_source(cop, 'x = 0 ')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for a blank line with space' do
inspect_source(cop, ' ')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for a line ending with tab' do
inspect_source(cop, "x = 0\t")
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for trailing whitespace in a heredoc string' do
inspect_source(cop, ['x = < "2.0"',
' def bar=(bar)',
' @bar = bar',
' end',
' end',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts reader nested within a module' do
inspect_source(cop,
['module Foo',
' begin',
' if RUBY_VERSION > "2.0"',
' def bar',
' @bar',
' end',
' end',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts writer nested within an instance_eval call' do
inspect_source(cop,
['something.instance_eval do',
' begin',
' if RUBY_VERSION > "2.0"',
' def bar=(bar)',
' @bar = bar',
' end',
' end',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts reader nested within an instance_eval calll' do
inspect_source(cop,
['something.instance_eval do',
' begin',
' if RUBY_VERSION > "2.0"',
' def bar',
' @bar',
' end',
' end',
' end',
'end'])
expect(cop.offenses).to be_empty
end
it 'flags a reader inside a class, inside an instance_eval call' do
inspect_source(cop,
['something.instance_eval do',
' class << @blah',
' begin',
' def bar',
' @bar',
' end',
' end',
' end',
'end'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(
['Use `attr_reader` to define trivial reader methods.']
)
end
context 'exact name match disabled' do
let(:cop_config) { { 'ExactNameMatch' => false } }
it 'registers an offense when names mismatch in writer' do
inspect_source(cop, ['def foo(val)',
' @f = val',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense when names mismatch in reader' do
inspect_source(cop, ['def foo',
' @f',
'end'])
expect(cop.offenses.size).to eq(1)
end
end
context 'disallow predicates' do
let(:cop_config) { { 'AllowPredicates' => false } }
it 'does not accept predicate-like reader' do
inspect_source(cop,
['def foo?',
' @foo',
'end'])
expect(cop.offenses.size).to eq(1)
end
end
context 'allow predicates' do
let(:cop_config) { { 'AllowPredicates' => true } }
it 'accepts predicate-like reader' do
inspect_source(cop,
['def foo?',
' @foo',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'with whitelist' do
let(:cop_config) { { 'Whitelist' => ['to_foo', 'bar='] } }
it 'accepts whitelisted reader' do
inspect_source(cop,
[' def to_foo',
' @foo',
' end'])
expect(cop.offenses).to be_empty
end
it 'accepts whitelisted writer' do
inspect_source(cop,
[' def bar=(bar)',
' @bar = bar',
' end'])
expect(cop.offenses).to be_empty
end
context 'with AllowPredicates: false' do
let(:cop_config) do
{ 'AllowPredicates' => false,
'Whitelist' => ['foo?'] }
end
it 'accepts whitelisted predicate' do
inspect_source(cop,
[' def foo?',
' @foo',
' end'])
expect(cop.offenses).to be_empty
end
end
end
context 'with DSL allowed' do
let(:cop_config) { { 'AllowDSLWriters' => true } }
it 'accepts DSL-style writer' do
inspect_source(cop,
['def foo(val)',
' @foo = val',
'end'])
expect(cop.offenses).to be_empty
end
end
context 'ignore class methods' do
let(:cop_config) { { 'IgnoreClassMethods' => true } }
it 'accepts class reader' do
inspect_source(cop,
['def self.foo',
' @foo',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts class writer' do
inspect_source(cop,
['def self.foo(val)',
' @foo = val',
'end'])
expect(cop.offenses).to be_empty
end
end
describe '#autocorrect' do
context 'trivial reader' do
let(:source) { trivial_reader }
let(:corrected_source) { 'attr_reader :foo' }
it 'autocorrects' do
expect(autocorrect_source(cop, source)).to eq(corrected_source)
end
end
context 'non-matching reader' do
let(:cop_config) { { 'ExactNameMatch' => false } }
let(:source) do
['def foo',
' @bar',
'end']
end
it 'does not autocorrect' do
expect(autocorrect_source(cop, source))
.to eq(source.join("\n"))
expect(cop.offenses.map(&:corrected?)).to eq [false]
end
end
context 'predicate reader, with AllowPredicates: false' do
let(:cop_config) { { 'AllowPredicates' => false } }
let(:source) do
['def foo?',
' @foo',
'end']
end
it 'does not autocorrect' do
expect(autocorrect_source(cop, source)).to eq(source.join("\n"))
expect(cop.offenses.map(&:corrected?)).to eq [false]
end
end
context 'trivial writer' do
let(:source) { trivial_writer }
let(:corrected_source) { 'attr_writer :foo' }
it 'autocorrects' do
expect(autocorrect_source(cop, source)).to eq(corrected_source)
end
end
context 'matching DSL-style writer' do
let(:source) do
['def foo(f)',
' @foo=f',
'end']
end
it 'does not autocorrect' do
expect(autocorrect_source(cop, source))
.to eq(source.join("\n"))
expect(cop.offenses.map(&:corrected?)).to eq [false]
end
end
context 'explicit receiver writer' do
let(:source) do
['def derp.foo=(f)',
' @foo=f',
'end']
end
it 'does not autocorrect' do
expect(autocorrect_source(cop, source))
.to eq(source.join("\n"))
expect(cop.offenses.map(&:corrected?)).to eq [false]
end
end
context 'class receiver reader' do
let(:source) do
['class Foo',
' def self.foo',
' @foo',
' end',
'end']
end
let(:corrected_source) do
['class Foo',
' class << self',
' attr_reader :foo',
' end',
'end']
end
it 'autocorrects with class-level attr_reader' do
expect(autocorrect_source(cop, source))
.to eq(corrected_source.join("\n"))
end
end
context 'class receiver writer' do
let(:source) do
['class Foo',
' def self.foo=(f)',
' @foo = f',
' end',
'end']
end
let(:corrected_source) do
['class Foo',
' class << self',
' attr_writer :foo',
' end',
'end']
end
it 'autocorrects with class-level attr_writer' do
expect(autocorrect_source(cop, source))
.to eq(corrected_source.join("\n"))
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/unless_else_spec.rb 0000664 0000000 0000000 00000003717 13070542236 0025351 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::UnlessElse do
subject(:cop) { described_class.new }
context 'unless with else' do
let(:source) do
['unless x # negative 1',
' a = 1 # negative 2',
'else # positive 1',
' a = 0 # positive 2',
'end']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'auto-corrects' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq(['if x # positive 1',
' a = 0 # positive 2',
'else # negative 1',
' a = 1 # negative 2',
'end'].join("\n"))
end
end
context 'unless with nested if-else' do
let(:source) do
['unless(x)',
' if(y == 0)',
' a = 0',
' elsif(z == 0)',
' a = 1',
' else',
' a = 2',
' end',
'else',
' a = 3',
'end']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'auto-corrects' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq(['if(x)',
' a = 3',
'else',
' if(y == 0)',
' a = 0',
' elsif(z == 0)',
' a = 1',
' else',
' a = 2',
' end',
'end'].join("\n"))
end
end
context 'unless without else' do
it 'does not register an offense' do
inspect_source(cop, ['unless x',
' a = 1',
'end'])
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/unneeded_capital_w_spec.rb 0000664 0000000 0000000 00000005312 13070542236 0026633 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::UnneededCapitalW do
subject(:cop) { described_class.new }
it 'registers no offense for normal arrays of strings' do
inspect_source(cop, '["one", "two", "three"]')
expect(cop.offenses).to be_empty
end
it 'registers no offense for normal arrays of strings with interpolation' do
inspect_source(cop, '["one", "two", "th#{?r}ee"]')
expect(cop.offenses).to be_empty
end
it 'registers an offense for misused %W' do
inspect_source(cop, '%W(cat dog)')
expect(cop.offenses.size).to eq(1)
end
it 'registers no offense for %W with interpolation' do
inspect_source(cop, '%W(c#{?a}t dog)')
expect(cop.offenses).to be_empty
end
it 'registers no offense for %W with special characters' do
source = ['def dangerous_characters',
' %W(\000) +',
' %W(\001) +',
' %W(\027) +',
' %W(\002) +',
' %W(\003) +',
' %W(\004) +',
' %W(\005) +',
' %W(\006) +',
' %W(\007) +',
' %W(\00) +',
' %W(\a)',
' %W(\s)',
' %W(\n)',
' %W(\!)',
'end']
inspect_source(cop, source)
expect(cop.offenses).to be_empty
end
it 'registers no offense for %w without interpolation' do
inspect_source(cop, '%w(cat dog)')
expect(cop.offenses).to be_empty
end
it 'registers no offense for %w with interpolation-like syntax' do
inspect_source(cop, '%w(c#{?a}t dog)')
expect(cop.offenses).to be_empty
end
it 'registers no offense for arrays with character constants' do
inspect_source(cop, '["one", ?\n]')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for array of non-words' do
inspect_source(cop, '["one space", "two", "three"]')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for array containing non-string' do
inspect_source(cop, '["one", "two", 3]')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for array with one element' do
inspect_source(cop, '["three"]')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for array with empty strings' do
inspect_source(cop, '["", "two", "three"]')
expect(cop.offenses).to be_empty
end
it 'auto-corrects an array of words' do
new_source = autocorrect_source(cop, '%W(one two three)')
expect(new_source).to eq('%w(one two three)')
end
it 'auto-corrects an array of words with different bracket' do
new_source = autocorrect_source(cop, '%W[one two three]')
expect(new_source).to eq('%w[one two three]')
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/unneeded_interpolation_spec.rb 0000664 0000000 0000000 00000010351 13070542236 0027556 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::UnneededInterpolation do
subject(:cop) { described_class.new }
it 'registers an offense for "#{1 + 1}"' do
inspect_source(cop, '"#{1 + 1}"')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['"#{1 + 1}"'])
end
it 'registers an offense for "%{#{1 + 1}}"' do
inspect_source(cop, '%{#{1 + 1}}')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['%{#{1 + 1}}'])
end
it 'registers an offense for "%Q(#{1 + 1})"' do
inspect_source(cop, '%Q(#{1 + 1})')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['%Q(#{1 + 1})'])
end
it 'registers an offense for "#{1 + 1; 2 + 2}"' do
inspect_source(cop, '"#{1 + 1; 2 + 2}"')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['"#{1 + 1; 2 + 2}"'])
end
it 'registers an offense for "#{@var}"' do
inspect_source(cop, '"#{@var}"')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['"#{@var}"'])
end
it 'registers an offense for "#@var"' do
inspect_source(cop, '"#@var"')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['"#@var"'])
end
it 'registers an offense for "#{@@var}"' do
inspect_source(cop, '"#{@@var}"')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['"#{@@var}"'])
end
it 'registers an offense for "#@@var"' do
inspect_source(cop, '"#@@var"')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['"#@@var"'])
end
it 'registers an offense for "#{$var}"' do
inspect_source(cop, '"#{$var}"')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['"#{$var}"'])
end
it 'registers an offense for "#$var"' do
inspect_source(cop, '"#$var"')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['"#$var"'])
end
it 'registers an offense for "#{$1}"' do
inspect_source(cop, '"#{$1}"')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['"#{$1}"'])
end
it 'registers an offense for "#$1"' do
inspect_source(cop, '"#$1"')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['"#$1"'])
end
it 'registers an offense for "#{$+}"' do
inspect_source(cop, '"#{$+}"')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['"#{$+}"'])
end
it 'registers an offense for "#$+"' do
inspect_source(cop, '"#$+"')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['"#$+"'])
end
it 'registers an offense for "#{var}"' do
inspect_source(cop, 'var = 1; "#{var}"')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['"#{var}"'])
end
it 'registers an offense for ["#{@var}"]' do
inspect_source(cop, '["#{@var}", \'foo\']')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['"#{@var}"'])
end
it 'accepts strings with characters before the interpolation' do
inspect_source(cop, '"this is #{@sparta}"')
expect(cop.offenses).to be_empty
end
it 'accepts strings with characters after the interpolation' do
inspect_source(cop, '"#{@sparta} this is"')
expect(cop.offenses).to be_empty
end
it 'accepts strings implicitly concatenated with a later string' do
inspect_source(cop, %q("#{sparta}" ' this is'))
expect(cop.offenses).to be_empty
end
it 'accepts strings implicitly concatenated with an earlier string' do
inspect_source(cop, %q('this is ' "#{sparta}"))
expect(cop.offenses).to be_empty
end
it 'accepts strings that are part of a %W()' do
inspect_source(cop, '%W(#{@var} foo)')
expect(cop.offenses).to be_empty
end
it 'autocorrects "#{1 + 1; 2 + 2}"' do
corrected = autocorrect_source(cop, ['"#{1 + 1; 2 + 2}"'])
expect(corrected).to eq '(1 + 1; 2 + 2).to_s'
end
it 'autocorrects "#@var"' do
corrected = autocorrect_source(cop, ['"#@var"'])
expect(corrected).to eq '@var.to_s'
end
it 'autocorrects "#{var}"' do
corrected = autocorrect_source(cop, ['var = 1; "#{var}"'])
expect(corrected).to eq 'var = 1; var.to_s'
end
it 'autocorrects "#{@var}"' do
corrected = autocorrect_source(cop, ['"#{@var}"'])
expect(corrected).to eq '@var.to_s'
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/unneeded_percent_q_spec.rb 0000664 0000000 0000000 00000013615 13070542236 0026655 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::UnneededPercentQ do
subject(:cop) { described_class.new }
context 'with %q strings' do
it 'registers an offense for only single quotes' do
inspect_source(cop, "%q('hi')")
expect(cop.messages).to eq(['Use `%q` only for strings that contain ' \
'both single quotes and double quotes.'])
end
it 'registers an offense for only double quotes' do
inspect_source(cop, '%q("hi")')
expect(cop.messages).to eq(['Use `%q` only for strings that contain ' \
'both single quotes and double quotes.'])
end
it 'registers an offense for no quotes' do
inspect_source(cop, '%q(hi)')
expect(cop.messages).to eq(['Use `%q` only for strings that contain ' \
'both single quotes and double quotes.'])
end
it 'accepts a string with single quotes and double quotes' do
inspect_source(cop, %q(%q('"hi"')))
expect(cop.messages).to be_empty
end
it 'registers an offfense for a string containing escaped backslashes' do
inspect_source(cop, '%q(\\\\foo\\\\)')
expect(cop.messages.length).to eq 1
end
it 'accepts a string with escaped non-backslash characters' do
inspect_source(cop, "%q(\\'foo\\')")
expect(cop.messages).to be_empty
end
it 'accepts a string with escaped backslash and non-backslash characters' do
inspect_source(cop, "%q(\\\\ \\'foo\\' \\\\)") # This is \\ \'foo\' \\
expect(cop.messages).to be_empty
end
it 'accepts regular expressions starting with %q' do
inspect_source(cop, '/%q?/')
expect(cop.messages).to be_empty
end
context 'auto-correct' do
it 'registers an offense for only single quotes' do
new_source = autocorrect_source(cop, "%q('hi')")
expect(new_source).to eq(%q("'hi'"))
end
it 'registers an offense for only double quotes' do
new_source = autocorrect_source(cop, '%q("hi")')
expect(new_source).to eq(%q('"hi"'))
end
it 'registers an offense for no quotes' do
new_source = autocorrect_source(cop, '%q(hi)')
expect(new_source).to eq("'hi'")
end
end
end
context 'with %Q strings' do
it 'registers an offense for static string without quotes' do
inspect_source(cop, '%Q(hi)')
expect(cop.messages).to eq(['Use `%Q` only for strings that contain ' \
'both single quotes and double quotes, or ' \
'for dynamic strings that contain double ' \
'quotes.'])
end
it 'registers an offense for static string with only double quotes' do
inspect_source(cop, '%Q("hi")')
expect(cop.messages).to eq(['Use `%Q` only for strings that contain ' \
'both single quotes and double quotes, or ' \
'for dynamic strings that contain double ' \
'quotes.'])
end
it 'registers an offense for dynamic string without quotes' do
inspect_source(cop, "%Q(hi\#{4})")
expect(cop.messages).to eq(['Use `%Q` only for strings that contain ' \
'both single quotes and double quotes, or ' \
'for dynamic strings that contain double ' \
'quotes.'])
end
it 'accepts a string with single quotes and double quotes' do
inspect_source(cop, %q(%Q('"hi"')))
expect(cop.messages).to be_empty
end
it 'accepts a string with double quotes and an escaped special character' do
inspect_source(cop, '%Q("\\thi")')
expect(cop.messages).to be_empty
end
it 'accepts a string with double quotes and an escaped normal character' do
inspect_source(cop, '%Q("\\!thi")')
expect(cop.messages).to be_empty
end
it 'accepts a dynamic %Q string with double quotes' do
inspect_source(cop, '%Q("hi#{4}")')
expect(cop.messages).to be_empty
end
it 'accepts regular expressions starting with %Q' do
inspect_source(cop, '/%Q?/')
expect(cop.messages).to be_empty
end
context 'auto-correct' do
it 'corrects a static string without quotes' do
new_source = autocorrect_source(cop, '%Q(hi)')
expect(new_source).to eq('"hi"')
end
it 'corrects a static string with only double quotes' do
new_source = autocorrect_source(cop, '%Q("hi")')
expect(new_source).to eq(%q('"hi"'))
end
it 'corrects a dynamic string without quotes' do
new_source = autocorrect_source(cop, "%Q(hi\#{4})")
expect(new_source).to eq(%("hi\#{4}"))
end
end
end
it 'accepts a heredoc string that contains %q' do
inspect_source(cop, [' s = < 'snake_case' } }
it 'registers an offense for camel case in local variable name' do
inspect_source(cop, 'myLocal = 1')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['myLocal'])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' =>
'camelCase')
end
it 'registers an offense for correct + opposite' do
inspect_source(cop, ['my_local = 1',
'myLocal = 1'])
expect(cop.highlights).to eq(['myLocal'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'registers an offense for camel case in instance variable name' do
inspect_source(cop, '@myAttribute = 3')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['@myAttribute'])
end
it 'registers an offense for camel case in class variable name' do
inspect_source(cop, '@@myAttr = 2')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['@@myAttr'])
end
it 'registers an offense for camel case in method parameter' do
inspect_source(cop, 'def method(funnyArg); end')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['funnyArg'])
end
it 'registers an offense for camel case local variables marked as unused' do
inspect_source(cop, '_myLocal = 1')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['_myLocal'])
end
include_examples 'always accepted'
end
context 'when configured for camelCase' do
let(:cop_config) { { 'EnforcedStyle' => 'camelCase' } }
it 'registers an offense for snake case in local variable name' do
inspect_source(cop, 'my_local = 1')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['my_local'])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' =>
'snake_case')
end
it 'registers an offense for opposite + correct' do
inspect_source(cop, ['my_local = 1',
'myLocal = 1'])
expect(cop.highlights).to eq(['my_local'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it 'accepts camel case in local variable name' do
inspect_source(cop, 'myLocal = 1')
expect(cop.offenses).to be_empty
end
it 'accepts camel case in instance variable name' do
inspect_source(cop, '@myAttribute = 3')
expect(cop.offenses).to be_empty
end
it 'accepts camel case in class variable name' do
inspect_source(cop, '@@myAttr = 2')
expect(cop.offenses).to be_empty
end
it 'registers an offense for snake case in method parameter' do
inspect_source(cop, 'def method(funny_arg); end')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['funny_arg'])
end
it 'accepts camel case local variables marked as unused' do
inspect_source(cop, '_myLocal = 1')
expect(cop.offenses).to be_empty
end
include_examples 'always accepted'
end
context 'when configured with a bad value' do
let(:cop_config) { { 'EnforcedStyle' => 'other' } }
it 'fails' do
expect { inspect_source(cop, 'a = 3') }
.to raise_error(RuntimeError)
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/variable_number_spec.rb 0000664 0000000 0000000 00000015475 13070542236 0026171 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::VariableNumber, :config do
subject(:cop) { described_class.new(config) }
shared_examples :offense do |style, variable, style_to_allow_offenses|
it "registers an offense for #{Array(variable).first} in #{style}" do
inspect_source(cop, Array(variable).map { |v| "#{v} = 1" }.join("\n"))
expect(cop.messages).to eq(["Use #{style} for variable numbers."])
expect(cop.highlights).to eq(Array(variable)[0, 1])
config_to_allow_offenses =
if style_to_allow_offenses
{ 'EnforcedStyle' => style_to_allow_offenses.to_s }
else
{ 'Enabled' => false }
end
expect(cop.config_to_allow_offenses).to eq(config_to_allow_offenses)
end
end
shared_examples :accepts do |style, variable|
it "accepts #{variable} in #{style}" do
inspect_source(cop, "#{variable} = 1")
expect(cop.offenses).to be_empty
end
end
context 'when configured for snake_case' do
let(:cop_config) { { 'EnforcedStyle' => 'snake_case' } }
it_behaves_like :offense, 'snake_case', 'local1', :normalcase
it_behaves_like :offense, 'snake_case', '@local1', :normalcase
it_behaves_like :offense, 'snake_case', '@@local1', :normalcase
it_behaves_like :offense, 'snake_case', 'camelCase1', :normalcase
it_behaves_like :offense, 'snake_case', '@camelCase1', :normalcase
it_behaves_like :offense, 'snake_case', '_unused1', :normalcase
it_behaves_like :offense, 'snake_case', 'aB1', :normalcase
it_behaves_like :offense, 'snake_case', %w[a1 a_2], nil
it_behaves_like :accepts, 'snake_case', 'local_1'
it_behaves_like :accepts, 'snake_case', 'local_12'
it_behaves_like :accepts, 'snake_case', 'local_123'
it_behaves_like :accepts, 'snake_case', 'local_'
it_behaves_like :accepts, 'snake_case', 'aB_1'
it_behaves_like :accepts, 'snake_case', 'a_1_b'
it_behaves_like :accepts, 'snake_case', 'a_1_b_1'
it_behaves_like :accepts, 'snake_case', '_'
it_behaves_like :accepts, 'snake_case', '_foo'
it_behaves_like :accepts, 'snake_case', '@foo'
it_behaves_like :accepts, 'snake_case', '@__foo__'
it 'registers an offense for normal case numbering in method parameter' do
inspect_source(cop, 'def method(arg1); end')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['arg1'])
end
it 'registers an offense for normal case numbering in method camel case
parameter' do
inspect_source(cop, 'def method(funnyArg1); end')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['funnyArg1'])
end
end
context 'when configured for normal' do
let(:cop_config) { { 'EnforcedStyle' => 'normalcase' } }
it_behaves_like :offense, 'normalcase', 'local_1', :snake_case
it_behaves_like :offense, 'normalcase', 'sha_256', :snake_case
it_behaves_like :offense, 'normalcase', '@local_1', :snake_case
it_behaves_like :offense, 'normalcase', '@@local_1', :snake_case
it_behaves_like :offense, 'normalcase', 'myAttribute_1', :snake_case
it_behaves_like :offense, 'normalcase', '@myAttribute_1', :snake_case
it_behaves_like :offense, 'normalcase', '_myLocal_1', :snake_case
it_behaves_like :offense, 'normalcase', 'localFOO_1', :snake_case
it_behaves_like :offense, 'normalcase', 'local_FOO_1', :snake_case
it_behaves_like :offense, 'normalcase', %w[a_1 a2], nil
it_behaves_like :accepts, 'normalcase', 'local1'
it_behaves_like :accepts, 'normalcase', 'local_'
it_behaves_like :accepts, 'normalcase', 'user1_id'
it_behaves_like :accepts, 'normalcase', 'sha256'
it_behaves_like :accepts, 'normalcase', 'foo10_bar'
it_behaves_like :accepts, 'normalcase', 'target_u2f_device'
it_behaves_like :accepts, 'normalcase', 'localFOO1'
it_behaves_like :accepts, 'normalcase', 'snake_case'
it_behaves_like :accepts, 'normalcase', 'user_1_id'
it_behaves_like :accepts, 'normalcase', '_'
it_behaves_like :accepts, 'normalcase', '_foo'
it_behaves_like :accepts, 'normalcase', '@foo'
it_behaves_like :accepts, 'normalcase', '@__foo__'
it 'registers an offense for snake case numbering in method parameter' do
inspect_source(cop, 'def method(arg_1); end')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['arg_1'])
end
it 'registers an offense for snake case numbering in method camel case
parameter' do
inspect_source(cop, 'def method(funnyArg_1); end')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['funnyArg_1'])
end
end
context 'when configured for non integer' do
let(:cop_config) { { 'EnforcedStyle' => 'non_integer' } }
it_behaves_like :offense, 'non_integer', 'local_1', :snake_case
it_behaves_like :offense, 'non_integer', 'local1', :normalcase
it_behaves_like :offense, 'non_integer', '@local_1', :snake_case
it_behaves_like :offense, 'non_integer', '@local1', :normalcase
it_behaves_like :offense, 'non_integer', 'myAttribute_1', :snake_case
it_behaves_like :offense, 'non_integer', 'myAttribute1', :normalcase
it_behaves_like :offense, 'non_integer', '@myAttribute_1', :snake_case
it_behaves_like :offense, 'non_integer', '@myAttribute1', :normalcase
it_behaves_like :offense, 'non_integer', '_myLocal_1', :snake_case
it_behaves_like :offense, 'non_integer', '_myLocal1', :normalcase
it_behaves_like :offense, 'non_integer', %w[a_1 aone], nil
it_behaves_like :accepts, 'non_integer', 'localone'
it_behaves_like :accepts, 'non_integer', 'local_one'
it_behaves_like :accepts, 'non_integer', 'local_'
it_behaves_like :accepts, 'non_integer', '@foo'
it_behaves_like :accepts, 'non_integer', '@@foo'
it_behaves_like :accepts, 'non_integer', 'fooBar'
it_behaves_like :accepts, 'non_integer', '_'
it_behaves_like :accepts, 'non_integer', '_foo'
it_behaves_like :accepts, 'non_integer', '@__foo__'
it 'registers an offense for snake case numbering in method parameter' do
inspect_source(cop, 'def method(arg_1); end')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['arg_1'])
end
it 'registers an offense for normal case numbering in method parameter' do
inspect_source(cop, 'def method(arg1); end')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['arg1'])
end
it 'registers an offense for snake case numbering in method camel case
parameter' do
inspect_source(cop, 'def method(myArg_1); end')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['myArg_1'])
end
it 'registers an offense for normal case numbering in method camel case
parameter' do
inspect_source(cop, 'def method(myArg1); end')
expect(cop.offenses.size).to eq(1)
expect(cop.highlights).to eq(['myArg1'])
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/when_then_spec.rb 0000664 0000000 0000000 00000003053 13070542236 0025000 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::WhenThen do
subject(:cop) { described_class.new }
it 'registers an offense for when x;' do
inspect_source(cop, ['case a',
'when b; c',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'accepts when x then' do
inspect_source(cop, ['case a',
'when b then c',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts ; separating statements in the body of when' do
inspect_source(cop, ['case a',
'when b then c; d',
'end',
'',
'case e',
'when f',
' g; h',
'end'])
expect(cop.offenses).to be_empty
end
it 'auto-corrects "when x;" with "when x then"' do
new_source = autocorrect_source(cop, ['case a',
'when b; c',
'end'])
expect(new_source).to eq(['case a',
'when b then c',
'end'].join("\n"))
end
# Regression: https://github.com/bbatsov/rubocop/issues/3868
context 'when inspecting a case statement with an empty branch' do
it 'does not register an offense' do
inspect_source(cop, ['case value',
'when cond1',
'end'])
expect(cop.offenses).to be_empty
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/while_until_do_spec.rb 0000664 0000000 0000000 00000003127 13070542236 0026030 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::WhileUntilDo do
subject(:cop) { described_class.new }
it 'registers an offense for do in multiline while' do
inspect_source(cop, ['while cond do',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for do in multiline until' do
inspect_source(cop, ['until cond do',
'end'])
expect(cop.offenses.size).to eq(1)
end
it 'accepts do in single-line while' do
inspect_source(cop, 'while cond do something end')
expect(cop.offenses).to be_empty
end
it 'accepts do in single-line until' do
inspect_source(cop, 'until cond do something end')
expect(cop.offenses).to be_empty
end
it 'accepts multi-line while without do' do
inspect_source(cop, ['while cond',
'end'])
expect(cop.offenses).to be_empty
end
it 'accepts multi-line until without do' do
inspect_source(cop, ['until cond',
'end'])
expect(cop.offenses).to be_empty
end
it 'auto-corrects the usage of "do" in multiline while' do
new_source = autocorrect_source(cop, ['while cond do',
'end'])
expect(new_source).to eq(['while cond',
'end'].join("\n"))
end
it 'auto-corrects the usage of "do" in multiline until' do
new_source = autocorrect_source(cop, ['until cond do',
'end'])
expect(new_source).to eq(['until cond',
'end'].join("\n"))
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/while_until_modifier_spec.rb 0000664 0000000 0000000 00000006270 13070542236 0027226 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::WhileUntilModifier do
include StatementModifierHelper
subject(:cop) { described_class.new(config) }
let(:config) do
hash = { 'Metrics/LineLength' => { 'Max' => 80 } }
RuboCop::Config.new(hash)
end
it "accepts multiline unless that doesn't fit on one line" do
check_too_long(cop, 'unless')
end
it 'accepts multiline unless whose body is more than one line' do
check_short_multiline(cop, 'unless')
end
context 'multiline while that fits on one line' do
it 'registers an offense' do
check_really_short(cop, 'while')
end
it 'does auto-correction' do
autocorrect_really_short(cop, 'while')
end
end
it "accepts multiline while that doesn't fit on one line" do
check_too_long(cop, 'while')
end
it 'accepts multiline while whose body is more than one line' do
check_short_multiline(cop, 'while')
end
it 'accepts oneline while when condition has local variable assignment' do
inspect_source(cop, ['lines = %w{first second third}',
'while (line = lines.shift)',
' puts line',
'end'])
expect(cop.offenses).to be_empty
end
context 'oneline while when assignment is in body' do
let(:source) do
['while true',
' x = 0',
'end']
end
it 'registers an offense' do
inspect_source(cop, source)
expect(cop.offenses.size).to eq(1)
end
it 'does auto-correction' do
corrected = autocorrect_source(cop, source)
expect(corrected).to eq 'x = 0 while true'
end
end
context 'multiline until that fits on one line' do
it 'registers an offense' do
check_really_short(cop, 'until')
end
it 'does auto-correction' do
autocorrect_really_short(cop, 'until')
end
end
it "accepts multiline until that doesn't fit on one line" do
check_too_long(cop, 'until')
end
it 'accepts multiline until whose body is more than one line' do
check_short_multiline(cop, 'until')
end
it 'accepts an empty condition' do
check_empty(cop, 'while')
check_empty(cop, 'until')
end
it 'accepts modifier while' do
inspect_source(cop, 'ala while bala')
expect(cop.offenses).to be_empty
end
it 'accepts modifier until' do
inspect_source(cop, 'ala until bala')
expect(cop.offenses).to be_empty
end
# Regression: https://github.com/bbatsov/rubocop/issues/4006
context 'when the modifier condition is multiline' do
it 'registers an offense' do
inspect_source(cop,
['foo while bar ||',
' baz'].join("\n"))
expect(cop.offenses.size).to eq(1)
end
end
context 'when the maximum line length is specified by the cop itself' do
let(:config) do
hash = {
'Metrics/LineLength' => { 'Max' => 100 },
'Style/WhileUntilModifier' => { 'MaxLineLength' => 80 }
}
RuboCop::Config.new(hash)
end
it "accepts multiline while that doesn't fit on one line" do
check_too_long(cop, 'while')
end
it "accepts multiline until that doesn't fit on one line" do
check_too_long(cop, 'until')
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/word_array_spec.rb 0000664 0000000 0000000 00000024055 13070542236 0025177 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::WordArray, :config do
subject(:cop) { described_class.new(config) }
before(:each) do
# Reset data which is shared by all instances of WordArray
described_class.largest_brackets = -Float::INFINITY
end
let(:other_cops) do
{
'Style/PercentLiteralDelimiters' => {
'PreferredDelimiters' => {
'default' => '()'
}
}
}
end
context 'when EnforcedStyle is percent' do
let(:cop_config) do
{ 'MinSize' => 0,
'WordRegex' => /\A[\p{Word}\n\t]+\z/,
'EnforcedStyle' => 'percent' }
end
it 'registers an offense for arrays of single quoted strings' do
inspect_source(cop, "['one', 'two', 'three']")
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Use `%w` or `%W` for an array of words.'])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'brackets')
end
it 'registers an offense for arrays of double quoted strings' do
inspect_source(cop, '["one", "two", "three"]')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for arrays of unicode word characters' do
inspect_source(cop, '["ВУЗ", "вуз", "中文网"]')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for arrays with character constants' do
inspect_source(cop, '["one", ?\n]')
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for strings with embedded newlines and tabs' do
inspect_source(cop, %(["one\n", "hi\tthere"]))
expect(cop.offenses.size).to eq(1)
end
it 'registers an offense for strings with newline and tab escapes' do
inspect_source(cop, %(["one\\n", "hi\\tthere"]))
expect(cop.offenses.size).to eq(1)
end
it 'uses %W when autocorrecting strings with newlines and tabs' do
new_source = autocorrect_source(cop, %(["one\\n", "hi\\tthere"]))
expect(new_source).to eq('%W(one\\n hi\\tthere)')
end
it 'does not register an offense for array of non-words' do
inspect_source(cop, '["one space", "two", "three"]')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for array containing non-string' do
inspect_source(cop, '["one", "two", 3]')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for array starting with %w' do
inspect_source(cop, '%w(one two three)')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for array with one element' do
inspect_source(cop, '["three"]')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for array with empty strings' do
inspect_source(cop, '["", "two", "three"]')
expect(cop.offenses).to be_empty
end
it 'does not register offense for array with allowed number of strings' do
cop_config['MinSize'] = 4
inspect_source(cop, '["one", "two", "three"]')
expect(cop.offenses).to be_empty
end
it 'does not register an offense for an array with comments in it' do
inspect_source(cop,
['[',
'"foo", # comment here',
'"bar", # this thing was done because of a bug',
'"baz" # do not delete this line',
']'])
expect(cop.offenses).to be_empty
end
it 'registers an offense for an array with comments outside of it' do
inspect_source(cop,
['[',
'"foo",',
'"bar",',
'"baz"',
'] # test'])
expect(cop.offenses.size).to eq(1)
end
it 'auto-corrects an array of words' do
new_source = autocorrect_source(cop, "['one', %q(two), 'three']")
expect(new_source).to eq('%w(one two three)')
end
it 'auto-corrects an array of words and character constants' do
new_source = autocorrect_source(cop, '[%{one}, %Q(two), ?\n, ?\t]')
expect(new_source).to eq('%W(one two \n \t)')
end
it 'keeps the line breaks in place after auto-correct' do
new_source = autocorrect_source(cop,
["['one',",
"'two', 'three']"])
expect(new_source).to eq(['%w(one ',
'two three)'].join("\n"))
end
it 'detects right value of MinSize to use for --auto-gen-config' do
inspect_source(cop,
["['one', 'two', 'three']",
'%w(a b c d)'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Use `%w` or `%W` for an array of words.'])
expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'percent',
'MinSize' => 4)
end
it 'detects when the cop must be disabled to avoid offenses' do
inspect_source(cop,
["['one', 'two', 'three']",
'%w(a b)'])
expect(cop.offenses.size).to eq(1)
expect(cop.messages).to eq(['Use `%w` or `%W` for an array of words.'])
expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
end
it "doesn't fail in wacky ways when multiple cop instances are used" do
# Regression test for GH issue #2740
cop1 = described_class.new(config)
cop2 = described_class.new(config)
RuboCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
# Don't use `inspect_source`; it resets `config_to_allow_offenses` each
# time, which suppresses the bug we are checking for
_investigate(cop1, parse_source("['g', 'h']"))
_investigate(cop2, parse_source('%w(a b c)'))
expect(cop2.config_to_allow_offenses).to eq('EnforcedStyle' => 'percent',
'MinSize' => 3)
end
end
context 'when EnforcedStyle is array' do
let(:cop_config) do
{ 'MinSize' => 0,
'WordRegex' => /\A[\p{Word}]+\z/,
'EnforcedStyle' => 'brackets' }
end
it 'does not register an offense for arrays of single quoted strings' do
inspect_source(cop, "['one', 'two', 'three']")
expect(cop.offenses).to be_empty
end
it 'does not register an offense for arrays of double quoted strings' do
inspect_source(cop, '["one", "two", "three"]')
expect(cop.offenses).to be_empty
end
it 'registers an offense for a %w() array' do
inspect_source(cop, '%w(one two three)')
expect(cop.offenses.size).to eq(1)
end
it 'auto-corrects a %w() array' do
new_source = autocorrect_source(cop, '%w(one two three)')
expect(new_source).to eq("['one', 'two', 'three']")
end
it 'autocorrects a %w() array which uses single quotes' do
new_source = autocorrect_source(cop, "%w(one's two's three's)")
expect(new_source).to eq('["one\'s", "two\'s", "three\'s"]')
end
it 'autocorrects a %W() array which uses escapes' do
new_source = autocorrect_source(cop, '%W(\\n \\t \\b \\v \\f)')
expect(new_source).to eq('["\n", "\t", "\b", "\v", "\f"]')
end
it "doesn't fail on strings which are not valid UTF-8" do
# Regression test, see GH issue 2671
inspect_source(cop, ['["\xC0",',
' "\xC2\x4a",',
' "\xC2\xC2",',
' "\x4a\x82",',
' "\x82\x82",',
' "\xe1\x82\x4a",',
']'])
# Currently, this cop completely ignores strings with invalid encoding
# If it could handle them and still report an offense when appropriate,
# that would be even better
expect(cop.offenses).to be_empty
end
end
context 'with a custom WordRegex configuration' do
let(:cop_config) { { 'MinSize' => 0, 'WordRegex' => /\A[\w@.]+\z/ } }
it 'registers an offense for arrays of email addresses' do
inspect_source(cop, "['a@example.com', 'b@example.com']")
expect(cop.offenses.size).to eq(1)
end
it 'auto-corrects an array of email addresses' do
new_source = autocorrect_source(cop, "['a@example.com', 'b@example.com']")
expect(new_source).to eq('%w(a@example.com b@example.com)')
end
end
context 'when the WordRegex configuration is not a Regexp' do
let(:cop_config) { { 'WordRegex' => 'just_a_string' } }
it 'still parses the code without raising an error' do
expect { inspect_source(cop, '') }.to_not raise_error
end
end
context 'with a WordRegex configuration which accepts almost anything' do
let(:cop_config) { { 'MinSize' => 0, 'WordRegex' => /\S+/ } }
it 'uses %W when autocorrecting strings with non-printable chars' do
new_source = autocorrect_source(cop, '["\x1f\x1e", "hello"]')
expect(new_source).to eq('%W(\u001F\u001E hello)')
end
it 'uses %w for strings which only appear to have an escape' do
new_source = autocorrect_source(cop, "['hi\\tthere', 'again\\n']")
expect(new_source).to eq('%w(hi\\tthere again\\n)')
end
end
context 'with a treacherous WordRegex configuration' do
let(:cop_config) { { 'MinSize' => 0, 'WordRegex' => /[\w \[\]\(\)]/ } }
it "doesn't break when words contain whitespace" do
new_source = autocorrect_source(cop, "['hi there', 'something\telse']")
expect(new_source).to eq("['hi there', 'something\telse']")
end
it "doesn't break when words contain delimiters" do
new_source = autocorrect_source(cop, "[')', ']', '(']")
expect(new_source).to eq('%w(\\) ] \\()')
end
context 'when PreferredDelimiters is specified' do
let(:other_cops) do
{
'Style/PercentLiteralDelimiters' => {
'PreferredDelimiters' => {
'default' => '[]'
}
}
}
end
it 'autocorrects an array with delimiters' do
new_source = autocorrect_source(cop, "[')', ']', '(', '[']")
expect(new_source).to eq('%w[) \\] ( \\[]')
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/style/zero_length_predicate_spec.rb 0000664 0000000 0000000 00000014324 13070542236 0027364 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Style::ZeroLengthPredicate do
subject(:cop) { described_class.new }
before do
inspect_source(cop, source)
end
shared_examples 'code with offense' do |code, message, expected|
context "when checking #{code}" do
let(:source) { code }
it 'registers an offense' do
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.message).to eq(message)
expect(cop.highlights).to eq([code])
end
it 'auto-corrects' do
expect(autocorrect_source(cop, code)).to eq expected
end
end
end
shared_examples 'code without offense' do |code|
let(:source) { code }
it 'does not register any offense' do
expect(cop.offenses).to be_empty
end
end
context 'with arrays' do
it_behaves_like 'code with offense', '[1, 2, 3].length == 0',
'Use `empty?` instead of `length == 0`.',
'[1, 2, 3].empty?'
it_behaves_like 'code with offense', '[1, 2, 3].size == 0',
'Use `empty?` instead of `size == 0`.',
'[1, 2, 3].empty?'
it_behaves_like 'code with offense', '0 == [1, 2, 3].length',
'Use `empty?` instead of `0 == length`.',
'[1, 2, 3].empty?'
it_behaves_like 'code with offense', '0 == [1, 2, 3].size',
'Use `empty?` instead of `0 == size`.',
'[1, 2, 3].empty?'
it_behaves_like 'code with offense', '[1, 2, 3].length < 1',
'Use `empty?` instead of `length < 1`.',
'[1, 2, 3].empty?'
it_behaves_like 'code with offense', '[1, 2, 3].size < 1',
'Use `empty?` instead of `size < 1`.',
'[1, 2, 3].empty?'
it_behaves_like 'code with offense', '1 > [1, 2, 3].length',
'Use `empty?` instead of `1 > length`.',
'[1, 2, 3].empty?'
it_behaves_like 'code with offense', '1 > [1, 2, 3].size',
'Use `empty?` instead of `1 > size`.',
'[1, 2, 3].empty?'
it_behaves_like 'code with offense', '[1, 2, 3].length > 0',
'Use `!empty?` instead of `length > 0`.',
'![1, 2, 3].empty?'
it_behaves_like 'code with offense', '[1, 2, 3].size > 0',
'Use `!empty?` instead of `size > 0`.',
'![1, 2, 3].empty?'
it_behaves_like 'code with offense', '[1, 2, 3].length != 0',
'Use `!empty?` instead of `length != 0`.',
'![1, 2, 3].empty?'
it_behaves_like 'code with offense', '[1, 2, 3].size != 0',
'Use `!empty?` instead of `size != 0`.',
'![1, 2, 3].empty?'
it_behaves_like 'code with offense', '0 < [1, 2, 3].length',
'Use `!empty?` instead of `0 < length`.',
'![1, 2, 3].empty?'
it_behaves_like 'code with offense', '0 < [1, 2, 3].size',
'Use `!empty?` instead of `0 < size`.',
'![1, 2, 3].empty?'
it_behaves_like 'code with offense', '0 != [1, 2, 3].length',
'Use `!empty?` instead of `0 != length`.',
'![1, 2, 3].empty?'
it_behaves_like 'code with offense', '0 != [1, 2, 3].size',
'Use `!empty?` instead of `0 != size`.',
'![1, 2, 3].empty?'
end
context 'with hashes' do
it_behaves_like 'code with offense', '{ a: 1, b: 2 }.size == 0',
'Use `empty?` instead of `size == 0`.',
'{ a: 1, b: 2 }.empty?'
it_behaves_like 'code with offense', '0 == { a: 1, b: 2 }.size',
'Use `empty?` instead of `0 == size`.',
'{ a: 1, b: 2 }.empty?'
it_behaves_like 'code with offense', '{ a: 1, b: 2 }.size != 0',
'Use `!empty?` instead of `size != 0`.',
'!{ a: 1, b: 2 }.empty?'
it_behaves_like 'code with offense', '0 != { a: 1, b: 2 }.size',
'Use `!empty?` instead of `0 != size`.',
'!{ a: 1, b: 2 }.empty?'
end
context 'with strings' do
it_behaves_like 'code with offense', '"string".size == 0',
'Use `empty?` instead of `size == 0`.',
'"string".empty?'
it_behaves_like 'code with offense', '0 == "string".size',
'Use `empty?` instead of `0 == size`.',
'"string".empty?'
it_behaves_like 'code with offense', '"string".size != 0',
'Use `!empty?` instead of `size != 0`.',
'!"string".empty?'
it_behaves_like 'code with offense', '0 != "string".size',
'Use `!empty?` instead of `0 != size`.',
'!"string".empty?'
end
context 'with collection variables' do
it_behaves_like 'code with offense', 'collection.size == 0',
'Use `empty?` instead of `size == 0`.',
'collection.empty?'
it_behaves_like 'code with offense', '0 == collection.size',
'Use `empty?` instead of `0 == size`.',
'collection.empty?'
it_behaves_like 'code with offense', 'collection.size != 0',
'Use `!empty?` instead of `size != 0`.',
'!collection.empty?'
it_behaves_like 'code with offense', '0 != collection.size',
'Use `!empty?` instead of `0 != size`.',
'!collection.empty?'
end
context 'when name of the variable is `size` or `length`' do
it_behaves_like 'code without offense', 'size == 0'
it_behaves_like 'code without offense', 'length == 0'
it_behaves_like 'code without offense', '0 == size'
it_behaves_like 'code without offense', '0 == length'
it_behaves_like 'code without offense', 'size <= 0'
it_behaves_like 'code without offense', 'length > 0'
it_behaves_like 'code without offense', '0 <= size'
it_behaves_like 'code without offense', '0 > length'
it_behaves_like 'code without offense', 'size != 0'
it_behaves_like 'code without offense', 'length != 0'
it_behaves_like 'code without offense', '0 != size'
it_behaves_like 'code without offense', '0 != length'
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/team_spec.rb 0000664 0000000 0000000 00000013640 13070542236 0022612 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Team do
subject(:team) { described_class.new(cop_classes, config, options) }
let(:cop_classes) { RuboCop::Cop::Cop.non_rails }
let(:config) { RuboCop::ConfigLoader.default_configuration }
let(:options) { nil }
let(:ruby_version) { RuboCop::Config::KNOWN_RUBIES.last }
before(:each) do
RuboCop::ConfigLoader.default_configuration = nil
end
describe 'INCOMPATIBLE_COPS' do
include FileHelper
let(:options) { { formatters: [], auto_correct: true } }
let(:runner) { RuboCop::Runner.new(options, RuboCop::ConfigStore.new) }
let(:file_path) { 'example.rb' }
it 'auto corrects without SyntaxError', :isolated_environment do
source = <<-'END'.strip_indent
foo.map{ |a| a.nil? }
'foo' +
'bar' +
"#{baz}"
i=i+1
END
corrected = <<-'END'.strip_indent
foo.map(&:nil?)
'foo' \
'bar' \
"#{baz}"
i += 1
END
create_file(file_path, source)
runner.run([])
expect(File.read(file_path)).to eq(corrected)
end
end
describe '#autocorrect?' do
subject { team.autocorrect? }
context 'when the option argument of .new is omitted' do
subject { described_class.new(cop_classes, config).autocorrect? }
it { is_expected.to be_falsey }
end
context 'when { auto_correct: true } is passed to .new' do
let(:options) { { auto_correct: true } }
it { is_expected.to be_truthy }
end
end
describe '#debug?' do
subject { team.debug? }
context 'when the option argument of .new is omitted' do
subject { described_class.new(cop_classes, config).debug? }
it { is_expected.to be_falsey }
end
context 'when { debug: true } is passed to .new' do
let(:options) { { debug: true } }
it { is_expected.to be_truthy }
end
end
describe '#inspect_file', :isolated_environment do
include FileHelper
let(:file_path) { '/tmp/example.rb' }
let(:offenses) do
source = RuboCop::ProcessedSource.from_file(file_path, ruby_version)
team.inspect_file(source)
end
before do
create_file(file_path, [
'#' * 90,
'puts test;'
])
end
it 'returns offenses' do
expect(offenses).not_to be_empty
expect(offenses.all? { |o| o.is_a?(RuboCop::Cop::Offense) }).to be_truthy
end
context 'when Parser reports non-fatal warning for the file' do
before do
create_file(file_path, ['#' * 90, 'puts *test'])
end
let(:cop_names) { offenses.map(&:cop_name) }
it 'returns Parser warning offenses' do
expect(cop_names).to include('Lint/AmbiguousOperator')
end
it 'returns offenses from cops' do
expect(cop_names).to include('Metrics/LineLength')
end
end
context 'when autocorrection is enabled' do
let(:options) { { auto_correct: true } }
before do
create_file(file_path, 'puts "string"')
end
it 'does autocorrection' do
source = RuboCop::ProcessedSource.from_file(file_path, ruby_version)
team.inspect_file(source)
corrected_source = File.read(file_path)
expect(corrected_source).to eq("puts 'string'\n")
end
it 'still returns offenses' do
expect(offenses.first.cop_name).to eq('Style/StringLiterals')
end
end
end
describe '#cops' do
subject(:cops) { team.cops }
it 'returns cop instances' do
expect(cops).not_to be_empty
expect(cops.all? { |c| c.is_a?(RuboCop::Cop::Cop) }).to be_truthy
end
context 'when only some cop classes are passed to .new' do
let(:cop_classes) do
RuboCop::Cop::Registry.new(
[RuboCop::Cop::Lint::Void, RuboCop::Cop::Metrics::LineLength]
)
end
it 'returns only instances of the classes' do
expect(cops.size).to eq(2)
cops.sort! { |a, b| a.name <=> b.name }
expect(cops[0].name).to eq('Lint/Void')
expect(cops[1].name).to eq('Metrics/LineLength')
end
end
context 'when some classes are disabled with config' do
let(:disabled_config) do
%w[
Lint/Void
Metrics/LineLength
].each_with_object(RuboCop::Config.new) do |cop_name, accum|
accum[cop_name] = { 'Enabled' => false }
end
end
let(:config) do
RuboCop::ConfigLoader.merge_with_default(disabled_config, '')
end
let(:cop_names) { cops.map(&:name) }
it 'does not return instances of the classes' do
expect(cops).not_to be_empty
expect(cop_names).not_to include('Lint/Void')
expect(cop_names).not_to include('Metrics/LineLength')
end
end
end
describe '#forces' do
subject(:forces) { team.forces }
let(:cop_classes) { RuboCop::Cop::Cop.non_rails }
it 'returns force instances' do
expect(forces).not_to be_empty
forces.each do |force|
expect(force).to be_a(RuboCop::Cop::Force)
end
end
context 'when a cop joined a force' do
let(:cop_classes) do
RuboCop::Cop::Registry.new([RuboCop::Cop::Lint::UselessAssignment])
end
it 'returns the force' do
expect(forces.size).to eq(1)
expect(forces.first).to be_a(RuboCop::Cop::VariableForce)
end
end
context 'when multiple cops joined a same force' do
let(:cop_classes) do
RuboCop::Cop::Registry.new(
[
RuboCop::Cop::Lint::UselessAssignment,
RuboCop::Cop::Lint::ShadowingOuterLocalVariable
]
)
end
it 'returns only one force instance' do
expect(forces.size).to eq(1)
end
end
context 'when no cops joined force' do
let(:cop_classes) do
RuboCop::Cop::Registry.new([RuboCop::Cop::Style::For])
end
it 'returns nothing' do
expect(forces).to be_empty
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/util_spec.rb 0000664 0000000 0000000 00000006740 13070542236 0022644 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::Util do
class TestUtil
include RuboCop::Cop::Util
end
describe '#line_range' do
let(:source) do
<<-END
foo = 1
bar = 2
class Test
def some_method
do_something
end
end
baz = 8
END
end
let(:processed_source) { parse_source(source) }
let(:ast) { processed_source.ast }
let(:node) { ast.each_node.find(&:class_type?) }
context 'when Source::Range object is passed' do
it 'returns line range of that' do
line_range = described_class.line_range(node.loc.expression)
expect(line_range).to eq(3..7)
end
end
context 'when AST::Node object is passed' do
it 'returns line range of the expression' do
line_range = described_class.line_range(node)
expect(line_range).to eq(3..7)
end
end
end
describe 'source indicated by #range_with_surrounding_comma' do
let(:source) { 'raise " ,Error, "' }
let(:processed_source) { parse_source(source) }
let(:input_range) do
Parser::Source::Range.new(processed_source.buffer, 9, 14)
end
subject do
obj = TestUtil.new
obj.instance_exec(processed_source) { |src| @processed_source = src }
r = obj.send(:range_with_surrounding_comma, input_range, side)
processed_source.buffer.source[r.begin_pos...r.end_pos]
end
context 'when side is :both' do
let(:side) { :both }
it { is_expected.to eq(',Error,') }
end
context 'when side is :left' do
let(:side) { :left }
it { is_expected.to eq(',Error') }
end
context 'when side is :right' do
let(:side) { :right }
it { is_expected.to eq('Error,') }
end
end
describe 'source indicated by #range_with_surrounding_space' do
let(:source) { 'f { a(2) }' }
let(:processed_source) { parse_source(source) }
let(:input_range) do
Parser::Source::Range.new(processed_source.buffer, 5, 9)
end
subject do
obj = TestUtil.new
obj.instance_exec(processed_source) { |src| @processed_source = src }
r = obj.send(:range_with_surrounding_space, input_range, side)
processed_source.buffer.source[r.begin_pos...r.end_pos]
end
context 'when side is :both' do
let(:side) { :both }
it { is_expected.to eq(' a(2) ') }
end
context 'when side is :left' do
let(:side) { :left }
it { is_expected.to eq(' a(2)') }
end
context 'when side is :right' do
let(:side) { :right }
it { is_expected.to eq('a(2) ') }
end
end
describe '#to_symbol_literal' do
[
['foo', ':foo'],
['foo?', ':foo?'],
['foo!', ':foo!'],
['@foo', ':@foo'],
['@@foo', ':@@foo'],
['$\\', ':$\\'],
['$a', ':$a'],
['==', ':=='],
['a-b', ":'a-b'"]
].each do |string, expectation|
context "when #{string}" do
it "returns #{expectation}" do
expect(described_class.to_symbol_literal(string)).to eq(expectation)
end
end
end
end
describe '#to_supported_styles' do
subject { described_class.to_supported_styles(enforced_style) }
context 'when EnforcedStyle' do
let(:enforced_style) { 'EnforcedStyle' }
it { is_expected.to eq('SupportedStyles') }
end
context 'when EnforcedStyleInsidePipes' do
let(:enforced_style) { 'EnforcedStyleInsidePipes' }
it { is_expected.to eq('SupportedStylesInsidePipes') }
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/variable_force/ 0000775 0000000 0000000 00000000000 13070542236 0023264 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/variable_force/assignment_spec.rb 0000664 0000000 0000000 00000010203 13070542236 0026767 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::VariableForce::Assignment do
include RuboCop::AST::Sexp
let(:ast) do
RuboCop::ProcessedSource.new(source, ruby_version).ast
end
let(:source) do
<<-END
class SomeClass
def some_method(flag)
puts 'Hello World!'
if flag > 0
foo = 1
end
end
end
END
end
let(:def_node) { ast.each_node.find(&:def_type?) }
let(:lvasgn_node) { ast.each_node.find(&:lvasgn_type?) }
let(:name) { lvasgn_node.children.first }
let(:scope) { RuboCop::Cop::VariableForce::Scope.new(def_node) }
let(:variable) do
RuboCop::Cop::VariableForce::Variable.new(name, lvasgn_node, scope)
end
let(:assignment) { described_class.new(lvasgn_node, variable) }
describe '.new' do
let(:variable) { double('variable') }
context 'when an assignment node is passed' do
it 'does not raise error' do
node = s(:lvasgn, :foo)
expect { described_class.new(node, variable) }.not_to raise_error
end
end
context 'when an argument declaration node is passed' do
it 'raises error' do
node = s(:arg, :foo)
expect { described_class.new(node, variable) }
.to raise_error(ArgumentError)
end
end
context 'when any other type node is passed' do
it 'raises error' do
node = s(:def)
expect { described_class.new(node, variable) }
.to raise_error(ArgumentError)
end
end
end
describe '#name' do
it 'returns the variable name' do
expect(assignment.name).to eq(:foo)
end
end
describe '#meta_assignment_node' do
context 'when it is += operator assignment' do
let(:source) do
<<-END
def some_method
foo += 1
end
END
end
it 'returns op_asgn node' do
expect(assignment.meta_assignment_node.type).to eq(:op_asgn)
end
end
context 'when it is ||= operator assignment' do
let(:source) do
<<-END
def some_method
foo ||= 1
end
END
end
it 'returns or_asgn node' do
expect(assignment.meta_assignment_node.type).to eq(:or_asgn)
end
end
context 'when it is &&= operator assignment' do
let(:source) do
<<-END
def some_method
foo &&= 1
end
END
end
it 'returns and_asgn node' do
expect(assignment.meta_assignment_node.type).to eq(:and_asgn)
end
end
context 'when it is multiple assignment' do
let(:source) do
<<-END
def some_method
foo, bar = [1, 2]
end
END
end
it 'returns masgn node' do
expect(assignment.meta_assignment_node.type).to eq(:masgn)
end
end
end
describe '#operator' do
context 'when it is normal assignment' do
let(:source) do
<<-END
def some_method
foo = 1
end
END
end
it 'returns =' do
expect(assignment.operator).to eq('=')
end
end
context 'when it is += operator assignment' do
let(:source) do
<<-END
def some_method
foo += 1
end
END
end
it 'returns +=' do
expect(assignment.operator).to eq('+=')
end
end
context 'when it is ||= operator assignment' do
let(:source) do
<<-END
def some_method
foo ||= 1
end
END
end
it 'returns ||=' do
expect(assignment.operator).to eq('||=')
end
end
context 'when it is &&= operator assignment' do
let(:source) do
<<-END
def some_method
foo &&= 1
end
END
end
it 'returns &&=' do
expect(assignment.operator).to eq('&&=')
end
end
context 'when it is multiple assignment' do
let(:source) do
<<-END
def some_method
foo, bar = [1, 2]
end
END
end
it 'returns =' do
expect(assignment.operator).to eq('=')
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/variable_force/reference_spec.rb 0000664 0000000 0000000 00000000712 13070542236 0026561 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'rubocop/ast/sexp'
describe RuboCop::Cop::VariableForce::Reference do
include RuboCop::AST::Sexp
describe '.new' do
context 'when non variable reference node is passed' do
it 'raises error' do
node = s(:def)
scope = RuboCop::Cop::VariableForce::Scope.new(s(:class))
expect { described_class.new(node, scope) }
.to raise_error(ArgumentError)
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/variable_force/scope_spec.rb 0000664 0000000 0000000 00000017600 13070542236 0025740 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::VariableForce::Scope do
include RuboCop::AST::Sexp
describe '.new' do
context 'when lvasgn node is passed' do
it 'accepts that as top level scope' do
node = s(:lvasgn)
expect { described_class.new(node) }.not_to raise_error
end
end
context 'when begin node is passed' do
it 'accepts that as top level scope' do
node = s(:begin)
expect { described_class.new(node) }.not_to raise_error
end
end
end
let(:ast) do
RuboCop::ProcessedSource.new(source, ruby_version).ast
end
let(:scope_node) { ast.each_node(scope_node_type).first }
subject(:scope) { described_class.new(scope_node) }
describe '#name' do
context 'when the scope is instance method definition' do
let(:source) { <<-END }
def some_method
end
END
let(:scope_node_type) { :def }
it 'returns the method name' do
expect(scope.name).to eq(:some_method)
end
end
context 'when the scope is singleton method definition' do
let(:source) { <<-END }
def self.some_method
end
END
let(:scope_node_type) { :defs }
it 'returns the method name' do
expect(scope.name).to eq(:some_method)
end
end
end
describe '#body_node' do
shared_examples 'returns the body node' do
it 'returns the body node' do
expect(scope.body_node.children[1]).to eq(:this_is_target)
end
end
context 'when the scope is instance method' do
let(:source) do
<<-END
def some_method
this_is_target
end
END
end
let(:scope_node_type) { :def }
include_examples 'returns the body node'
end
context 'when the scope is singleton method' do
let(:source) do
<<-END
def self.some_method
this_is_target
end
END
end
let(:scope_node_type) { :defs }
include_examples 'returns the body node'
end
context 'when the scope is module' do
let(:source) do
<<-END
module SomeModule
this_is_target
end
END
end
let(:scope_node_type) { :module }
include_examples 'returns the body node'
end
context 'when the scope is class' do
let(:source) do
<<-END
class SomeClass
this_is_target
end
END
end
let(:scope_node_type) { :class }
include_examples 'returns the body node'
end
context 'when the scope is singleton class' do
let(:source) do
<<-END
class << self
this_is_target
end
END
end
let(:scope_node_type) { :sclass }
include_examples 'returns the body node'
end
context 'when the scope is block' do
let(:source) do
<<-END
1.times do
this_is_target
end
END
end
let(:scope_node_type) { :block }
include_examples 'returns the body node'
end
context 'when the scope is top level' do
let(:source) do
<<-END
this_is_target
END
end
let(:scope_node_type) { :send }
include_examples 'returns the body node'
end
end
describe '#include?' do
subject do
scope.include?(target_node)
end
let(:source) { <<-END }
class SomeClass
def self.some_method(arg1, arg2)
do_something
1.times do
foo = 1
end
end
end
END
let(:scope_node_type) { :defs }
context 'with ancestor node the scope does not include' do
let(:target_node) do
ast
end
it { should be false }
end
context 'with node of the scope itself' do
let(:target_node) do
ast.each_node.find(&:defs_type?)
end
it { should be false }
end
context 'with child node the scope does not include' do
let(:target_node) do
ast.each_node.find(&:self_type?)
end
it { should be false }
end
context 'with child node the scope includes' do
let(:target_node) do
ast.each_node.find(&:send_type?)
end
it { should be true }
end
context 'with descendant node the scope does not include' do
let(:target_node) do
ast.each_node.find(&:lvasgn_type?)
end
it { should be false }
end
end
describe '#each_node' do
shared_examples 'yields' do |description|
it "yields #{description}" do
yielded_types = []
scope.each_node do |node|
yielded_types << node.type
end
expect(yielded_types).to eq(expected_types.map(&:to_sym))
end
end
describe 'outer scope boundary handling' do
context 'when the scope is instance method' do
let(:source) { <<-END }
def some_method(arg1, arg2)
:body
end
END
let(:scope_node_type) { :def }
let(:expected_types) { %w[args arg arg sym] }
include_examples 'yields', 'the argument and the body nodes'
end
context 'when the scope is singleton method' do
let(:source) { <<-END }
def self.some_method(arg1, arg2)
:body
end
END
let(:scope_node_type) { :defs }
let(:expected_types) { %w[args arg arg sym] }
include_examples 'yields', 'the argument and the body nodes'
end
context 'when the scope is module' do
let(:source) { <<-END }
module SomeModule
:body
end
END
let(:scope_node_type) { :module }
let(:expected_types) { %w[sym] }
include_examples 'yields', 'the body nodes'
end
context 'when the scope is class' do
let(:source) { <<-END }
some_super_class = Class.new
class SomeClass < some_super_class
:body
end
END
let(:scope_node_type) { :class }
let(:expected_types) { %w[sym] }
include_examples 'yields', 'the body nodes'
end
context 'when the scope is singleton class' do
let(:source) { <<-END }
some_object = Object.new
class << some_object
:body
end
END
let(:scope_node_type) { :sclass }
let(:expected_types) { %w[sym] }
include_examples 'yields', 'the body nodes'
end
context 'when the scope is block' do
let(:source) { <<-END }
1.times do |arg1, arg2|
:body
end
END
let(:scope_node_type) { :block }
let(:expected_types) { %w[args arg arg sym] }
include_examples 'yields', 'the argument and the body nodes'
end
context 'when the scope is top level' do
let(:source) { <<-END }
:body
END
let(:scope_node_type) { :sym }
let(:expected_types) { %w[sym] }
include_examples 'yields', 'the body nodes'
end
end
describe 'inner scope boundary handling' do
context "when there's a method invocation with block" do
let(:source) { <<-END }
foo = 1
do_something(1, 2) do |arg|
:body
end
foo
END
let(:scope_node_type) { :begin }
let(:expected_types) { %w[begin lvasgn int block send int int lvar] }
include_examples 'yields', 'only the block node and the child send node'
end
context "when there's a singleton method definition" do
let(:source) { <<-END }
foo = 1
def self.some_method(arg1, arg2)
:body
end
foo
END
let(:scope_node_type) { :begin }
let(:expected_types) { %w[begin lvasgn int defs self lvar] }
include_examples 'yields', 'only the defs node and the method host node'
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/variable_force/variable_spec.rb 0000664 0000000 0000000 00000002676 13070542236 0026423 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'rubocop/ast/sexp'
describe RuboCop::Cop::VariableForce::Variable do
include RuboCop::AST::Sexp
describe '.new' do
context 'when non variable declaration node is passed' do
it 'raises error' do
name = :foo
declaration_node = s(:def)
scope = RuboCop::Cop::VariableForce::Scope.new(s(:class))
expect { described_class.new(name, declaration_node, scope) }
.to raise_error(ArgumentError)
end
end
end
describe '#referenced?' do
let(:name) { :foo }
let(:declaration_node) { s(:arg, name) }
let(:scope) { double('scope').as_null_object }
let(:variable) { described_class.new(name, declaration_node, scope) }
subject { variable.referenced? }
context 'when the variable is not assigned' do
it { is_expected.to be_falsey }
context 'and the variable is referenced' do
before do
variable.reference!(s(:lvar, name))
end
it { is_expected.to be_truthy }
end
end
context 'when the variable has an assignment' do
before do
variable.assign(s(:lvasgn, name))
end
context 'and the variable is not yet referenced' do
it { is_expected.to be_falsey }
end
context 'and the variable is referenced' do
before do
variable.reference!(s(:lvar, name))
end
it { is_expected.to be_truthy }
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/variable_force/variable_table_spec.rb 0000664 0000000 0000000 00000020407 13070542236 0027562 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Cop::VariableForce::VariableTable do
include RuboCop::AST::Sexp
subject(:variable_table) { described_class.new }
describe '#push_scope' do
it 'returns pushed scope object' do
node = s(:def)
scope = variable_table.push_scope(node)
expect(scope).to equal(variable_table.current_scope)
expect(scope.node).to equal(node)
end
end
describe '#pop_scope' do
before do
node = s(:def)
variable_table.push_scope(node)
end
it 'returns popped scope object' do
last_scope = variable_table.current_scope
popped_scope = variable_table.pop_scope
expect(popped_scope).to equal(last_scope)
end
end
describe '#current_scope_level' do
before do
variable_table.push_scope(s(:def))
end
it 'increases by pushing scope' do
last_scope_level = variable_table.current_scope_level
variable_table.push_scope(s(:def))
expect(variable_table.current_scope_level)
.to eq(last_scope_level + 1)
end
it 'decreases by popping scope' do
last_scope_level = variable_table.current_scope_level
variable_table.pop_scope
expect(variable_table.current_scope_level)
.to eq(last_scope_level - 1)
end
end
describe '#declare_variable' do
before do
2.times do
node = s(:def)
variable_table.push_scope(node)
end
end
it 'adds variable to current scope with its name as key' do
node = s(:lvasgn, :foo)
variable_table.declare_variable(:foo, node)
expect(variable_table.current_scope.variables)
.to have_key(:foo)
expect(variable_table.scope_stack[-2].variables)
.to be_empty
variable = variable_table.current_scope.variables[:foo]
expect(variable.declaration_node).to equal(node)
end
it 'returns the added variable' do
node = s(:lvasgn, :foo)
variable = variable_table.declare_variable(:foo, node)
expect(variable.declaration_node).to equal(node)
end
end
describe '#find_variable' do
before do
variable_table.push_scope(s(:class))
variable_table.declare_variable(:baz, s(:lvasgn, :baz))
variable_table.push_scope(s(:def))
variable_table.declare_variable(:bar, s(:lvasgn, :bar))
end
context 'when current scope is block' do
before do
variable_table.push_scope(s(:block))
end
context 'when a variable with the target name exists ' \
'in current scope' do
before do
variable_table.declare_variable(:foo, s(:lvasgn, :foo))
end
context 'and does not exist in outer scope' do
it 'returns the current scope variable' do
found_variable = variable_table.find_variable(:foo)
expect(found_variable.name).to eq(:foo)
end
end
context 'and also exists in outer scope' do
before do
variable_table.declare_variable(:bar, s(:lvasgn, :bar))
end
it 'returns the current scope variable' do
found_variable = variable_table.find_variable(:bar)
expect(found_variable.name).to equal(:bar)
expect(variable_table.current_scope.variables)
.to have_value(found_variable)
expect(variable_table.scope_stack[-2].variables)
.not_to have_value(found_variable)
end
end
end
context 'when a variable with the target name does not exist ' \
'in current scope' do
context 'but exists in the direct outer scope' do
it 'returns the direct outer scope variable' do
found_variable = variable_table.find_variable(:bar)
expect(found_variable.name).to equal(:bar)
end
end
context 'but exists in a indirect outer scope' do
context 'when the direct outer scope is block' do
before do
variable_table.pop_scope
variable_table.pop_scope
variable_table.push_scope(s(:block))
variable_table.push_scope(s(:block))
end
it 'returns the indirect outer scope variable' do
found_variable = variable_table.find_variable(:baz)
expect(found_variable.name).to equal(:baz)
end
end
context 'when the direct outer scope is not block' do
it 'returns nil' do
found_variable = variable_table.find_variable(:baz)
expect(found_variable).to be_nil
end
end
end
context 'and does not exist in all outer scopes' do
it 'returns nil' do
found_variable = variable_table.find_variable(:non)
expect(found_variable).to be_nil
end
end
end
end
context 'when current scope is not block' do
before do
variable_table.push_scope(s(:def))
end
context 'when a variable with the target name exists ' \
'in current scope' do
before do
variable_table.declare_variable(:foo, s(:lvasgn, :foo))
end
context 'and does not exist in outer scope' do
it 'returns the current scope variable' do
found_variable = variable_table.find_variable(:foo)
expect(found_variable.name).to eq(:foo)
end
end
context 'and also exists in outer scope' do
it 'returns the current scope variable' do
found_variable = variable_table.find_variable(:foo)
expect(found_variable.name).to equal(:foo)
expect(variable_table.current_scope.variables)
.to have_value(found_variable)
expect(variable_table.scope_stack[-2].variables)
.not_to have_value(found_variable)
end
end
end
context 'when a variable with the target name does not exist ' \
'in current scope' do
context 'but exists in the direct outer scope' do
it 'returns nil' do
found_variable = variable_table.find_variable(:bar)
expect(found_variable).to be_nil
end
end
context 'and does not exist in all outer scopes' do
it 'returns nil' do
found_variable = variable_table.find_variable(:non)
expect(found_variable).to be_nil
end
end
end
end
end
describe '#find_variable with an empty scope stack' do
it 'returns nil' do
found_variable = variable_table.find_variable(:unknown)
expect(found_variable).to be_nil
end
end
describe '#accessible_variables' do
let(:accessible_variable_names) do
variable_table.accessible_variables.map(&:name)
end
before do
variable_table.push_scope(s(:class))
end
context 'when there are no variables' do
it 'returns empty array' do
expect(variable_table.accessible_variables).to be_empty
end
end
context 'when the current scope has some variables' do
before do
variable_table.declare_variable(:foo, s(:lvasgn, :foo))
variable_table.declare_variable(:bar, s(:lvasgn, :bar))
end
it 'returns all the variables' do
expect(accessible_variable_names).to contain_exactly(:foo, :bar)
end
end
context 'when the direct outer scope has some variables' do
before do
variable_table.declare_variable(:foo, s(:lvasgn, :foo))
end
context 'and the current scope is block' do
before do
variable_table.push_scope(s(:block))
variable_table.declare_variable(:bar, s(:lvasgn, :bar))
variable_table.declare_variable(:baz, s(:lvasgn, :baz))
end
it 'returns the current and direct outer scope variables' do
expect(accessible_variable_names)
.to contain_exactly(:foo, :bar, :baz)
end
end
context 'and the current scope is not block' do
before do
variable_table.push_scope(s(:def))
variable_table.declare_variable(:bar, s(:lvasgn, :bar))
variable_table.declare_variable(:baz, s(:lvasgn, :baz))
end
it 'returns only the current scope variables' do
expect(accessible_variable_names).to contain_exactly(:bar, :baz)
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/cop/variable_force_spec.rb 0000664 0000000 0000000 00000001440 13070542236 0024622 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'rubocop/ast/sexp'
describe RuboCop::Cop::VariableForce do
include RuboCop::AST::Sexp
subject(:force) { described_class.new([]) }
describe '#process_node' do
before do
force.variable_table.push_scope(s(:def))
end
context 'when processing lvar node' do
let(:node) { s(:lvar, :foo) }
context 'when the variable is not yet declared' do
it 'does not raise error' do
expect { force.process_node(node) }.not_to raise_error
end
end
end
context 'when processing an empty regex' do
let(:node) { s(:match_with_lvasgn, s(:regexp, s(:regopt)), s(:str)) }
it 'does not raise an error' do
expect { force.process_node(node) }.not_to raise_error
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/formatter/ 0000775 0000000 0000000 00000000000 13070542236 0021543 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/spec/rubocop/formatter/base_formatter_spec.rb 0000664 0000000 0000000 00000012561 13070542236 0026104 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module RuboCop
module Formatter
describe BaseFormatter do
include FileHelper
describe 'how the API methods are invoked', :isolated_environment do
subject(:formatter) { double('formatter').as_null_object }
let(:runner) { Runner.new({}, ConfigStore.new) }
let(:output) { $stdout.string }
before do
create_file('1_offense.rb', '#' * 90)
create_file('4_offenses.rb', ['puts x ', 'test;', 'top;', '#' * 90])
create_file('no_offense.rb', '# encoding: utf-8')
allow(SimpleTextFormatter).to receive(:new).and_return(formatter)
$stdout = StringIO.new
# avoid intermittent failure caused when another test set global
# options on ConfigLoader
ConfigLoader.clear_options
end
after do
$stdout = STDOUT
end
def run
runner.run([])
end
describe 'invocation order' do
subject(:formatter) do
formatter = double('formatter')
%i[started file_started file_finished finished output]
.each do |message|
allow(formatter).to receive(message) do
puts message.to_s unless message == :output
end
end
formatter
end
it 'is called in the proper sequence' do
run
expect(output).to eq([
'started',
'file_started',
'file_finished',
'file_started',
'file_finished',
'file_started',
'file_finished',
'finished',
''
].join("\n"))
end
end
shared_examples 'receives all file paths' do |method_name|
it 'receives all file paths' do
expected_paths = [
'1_offense.rb',
'4_offenses.rb',
'no_offense.rb'
].map { |path| File.expand_path(path) }.sort
expect(formatter).to receive(method_name) do |all_files|
expect(all_files.sort).to eq(expected_paths)
end
run
end
describe 'the passed files paths' do
it 'is frozen' do
expect(formatter).to receive(method_name) do |all_files|
all_files.each do |path|
expect(path).to be_frozen
end
end
run
end
end
end
describe '#started' do
include_examples 'receives all file paths', :started
end
describe '#finished' do
context 'when RuboCop finished inspecting all files normally' do
include_examples 'receives all file paths', :started
end
context 'when RuboCop is interrupted by user' do
it 'receives only processed file paths' do
class << formatter
attr_reader :processed_file_count
def file_finished(_file, _offenses)
@processed_file_count ||= 0
@processed_file_count += 1
end
end
allow(runner).to receive(:aborting?) do
formatter.processed_file_count == 2
end
expect(formatter).to receive(:finished) do |processed_files|
expect(processed_files.size).to eq(2)
end
run
end
end
end
shared_examples 'receives a file path' do |method_name|
it 'receives a file path' do
expect(formatter).to receive(method_name)
.with(File.expand_path('1_offense.rb'), anything)
expect(formatter).to receive(method_name)
.with(File.expand_path('4_offenses.rb'), anything)
expect(formatter).to receive(method_name)
.with(File.expand_path('no_offense.rb'), anything)
run
end
describe 'the passed path' do
it 'is frozen' do
expect(formatter)
.to receive(method_name).exactly(3).times do |path|
expect(path).to be_frozen
end
run
end
end
end
describe '#file_started' do
include_examples 'receives a file path', :file_started
it 'receives file specific information hash' do
expect(formatter).to receive(:file_started)
.with(anything, an_instance_of(Hash)).exactly(3).times
run
end
end
describe '#file_finished' do
include_examples 'receives a file path', :file_finished
it 'receives an array of detected offenses for the file' do
expect(formatter).to receive(:file_finished)
.exactly(3).times do |file, offenses|
case File.basename(file)
when '1_offense.rb'
expect(offenses.size).to eq(1)
when '4_offenses.rb'
expect(offenses.size).to eq(4)
when 'no_offense.rb'
expect(offenses).to be_empty
else
raise
end
expect(offenses.all? { |o| o.is_a?(RuboCop::Cop::Offense) })
.to be_truthy
end
run
end
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/formatter/clang_style_formatter_spec.rb 0000664 0000000 0000000 00000010102 13070542236 0027463 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module RuboCop
module Formatter
describe ClangStyleFormatter do
subject(:formatter) { described_class.new(output) }
let(:output) { StringIO.new }
describe '#report_file' do
it 'displays text containing the offending source line' do
cop = Cop::Cop.new
source_buffer = Parser::Source::Buffer.new('test', 1)
source_buffer.source = ('aa'..'az').to_a.join($RS)
cop.add_offense(nil,
Parser::Source::Range.new(source_buffer, 0, 2),
'message 1')
cop.add_offense(nil,
Parser::Source::Range.new(source_buffer, 30, 32),
'message 2')
formatter.report_file('test', cop.offenses)
expect(output.string).to eq ['test:1:1: C: message 1',
'aa',
'^^',
'test:11:1: C: message 2',
'ak',
'^^',
''].join("\n")
end
context 'when the source line is blank' do
it 'does not display offending source line' do
cop = Cop::Cop.new
source_buffer = Parser::Source::Buffer.new('test', 1)
source_buffer.source = [' ', 'yaba'].join($RS)
cop.add_offense(nil,
Parser::Source::Range.new(source_buffer, 0, 2),
'message 1')
cop.add_offense(nil,
Parser::Source::Range.new(source_buffer, 6, 10),
'message 2')
formatter.report_file('test', cop.offenses)
expect(output.string).to eq ['test:1:1: C: message 1',
'test:2:1: C: message 2',
'yaba',
'^^^^',
''].join("\n")
end
end
context 'when the offending source spans multiple lines' do
it 'displays the first line with ellipses' do
source = ['do_something([this,',
' is,',
' target])'].join($RS)
source_buffer = Parser::Source::Buffer.new('test', 1)
source_buffer.source = source
location = Parser::Source::Range.new(source_buffer,
source.index('['),
source.index(']') + 1)
cop = Cop::Cop.new
cop.add_offense(nil, location, 'message 1')
formatter.report_file('test', cop.offenses)
expect(output.string)
.to eq ['test:1:14: C: message 1',
"do_something([this, #{described_class::ELLIPSES}",
' ^^^^^^',
''].join("\n")
end
end
let(:file) { '/path/to/file' }
let(:offense) do
Cop::Offense.new(:convention, location,
'This is a message.', 'CopName', status)
end
let(:location) do
source_buffer = Parser::Source::Buffer.new('test', 1)
source_buffer.source = "a\n"
Parser::Source::Range.new(source_buffer, 0, 1)
end
context 'when the offense is not corrected' do
let(:status) { :uncorrected }
it 'prints message as-is' do
formatter.report_file(file, [offense])
expect(output.string)
.to include(': This is a message.')
end
end
context 'when the offense is automatically corrected' do
let(:status) { :corrected }
it 'prints [Corrected] along with message' do
formatter.report_file(file, [offense])
expect(output.string)
.to include(': [Corrected] This is a message.')
end
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/formatter/colorizable_spec.rb 0000664 0000000 0000000 00000005335 13070542236 0025415 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module RuboCop
module Formatter
describe Colorizable do
let(:formatter_class) do
Class.new(BaseFormatter) do
include Colorizable
end
end
let(:options) { {} }
let(:formatter) do
formatter_class.new(output, options)
end
let(:output) { double('output') }
around do |example|
original_state = Rainbow.enabled
begin
example.run
ensure
Rainbow.enabled = original_state
end
end
describe '#colorize' do
subject { formatter.colorize('foo', :red) }
shared_examples 'does nothing' do
it 'does nothing' do
is_expected.to eq('foo')
end
end
context 'when the global Rainbow.enabled is true' do
before do
Rainbow.enabled = true
end
context "and the formatter's output is a tty" do
before do
allow(output).to receive(:tty?).and_return(true)
end
it 'colorizes the passed string' do
is_expected.to eq("\e[31mfoo\e[0m")
end
end
context "and the formatter's output is not a tty" do
before do
allow(output).to receive(:tty?).and_return(false)
end
include_examples 'does nothing'
end
context 'and output is not a tty, but --color option was provided' do
let(:options) { { color: true } }
before do
allow(output).to receive(:tty?).and_return(false)
end
it 'colorizes the passed string' do
is_expected.to eq("\e[31mfoo\e[0m")
end
end
end
context 'when the global Rainbow.enabled is false' do
before do
Rainbow.enabled = false
end
context "and the formatter's output is a tty" do
before do
allow(output).to receive(:tty?).and_return(true)
end
include_examples 'does nothing'
end
context "and the formatter's output is not a tty" do
before do
allow(output).to receive(:tty?).and_return(false)
end
include_examples 'does nothing'
end
end
end
%i[
black
red
green
yellow
blue
magenta
cyan
white
].each do |color|
describe "##{color}" do
it "invokes #colorize(string, #{color}" do
expect(formatter).to receive(:colorize).with('foo', color)
formatter.send(color, 'foo')
end
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/formatter/disabled_config_formatter_spec.rb 0000664 0000000 0000000 00000016203 13070542236 0030263 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module RuboCop
module Formatter
describe DisabledConfigFormatter, :isolated_environment do
include FileHelper
subject(:formatter) { described_class.new(output) }
let(:output) do
o = StringIO.new
def o.path
'.rubocop_todo.yml'
end
o
end
let(:offenses) do
[RuboCop::Cop::Offense.new(:convention, location, 'message', 'Cop1'),
RuboCop::Cop::Offense.new(:convention, location, 'message', 'Cop2')]
end
let(:location) { OpenStruct.new(line: 1, column: 5) }
before do
$stderr = StringIO.new
$stdout = StringIO.new
# Avoid intermittent failure when another test set ConfigLoader options
ConfigLoader.clear_options
end
after do
$stderr = STDERR
$stdout = STDOUT
end
describe '#finished' do
it 'displays YAML configuration disabling all cops with offenses' do
formatter.file_started('test_a.rb', {})
formatter.file_finished('test_a.rb', offenses)
formatter.file_started('test_b.rb', {})
formatter.file_finished('test_b.rb', [offenses.first])
formatter.finished(['test_a.rb', 'test_b.rb'])
expect(output.string).to eq(format(described_class::HEADING,
'rubocop --auto-gen-config') +
['',
'',
'# Offense count: 2',
'Cop1:',
' Exclude:',
" - 'test_a.rb'",
" - 'test_b.rb'",
'',
'# Offense count: 1',
'Cop2:',
' Exclude:',
" - 'test_a.rb'",
''].join("\n"))
expect($stdout.string)
.to eq(['Created .rubocop_todo.yml.',
'Run `rubocop --config .rubocop_todo.yml`, or ' \
'add `inherit_from: .rubocop_todo.yml` in a .rubocop.yml ' \
'file.',
''].join("\n"))
end
it 'merges in excludes from .rubocop.yml' do
create_file('.rubocop.yml', ['Cop1:',
' Exclude:',
' - Gemfile',
'Cop2:',
' Exclude:',
' - "**/*.blah"'])
formatter.file_started('test_a.rb', {})
formatter.file_finished('test_a.rb', offenses)
formatter.file_started('test_b.rb', {})
formatter.file_finished('test_b.rb', [offenses.first])
formatter.finished(['test_a.rb', 'test_b.rb'])
expect(output.string).to eq(format(described_class::HEADING,
'rubocop --auto-gen-config') +
['',
'',
'# Offense count: 2',
'Cop1:',
' Exclude:',
" - 'Gemfile'",
" - 'test_a.rb'",
" - 'test_b.rb'",
'',
'# Offense count: 1',
'Cop2:',
' Exclude:',
" - '**/*.blah'",
" - 'test_a.rb'",
''].join("\n"))
end
it 'displays a file exclusion list up to a maximum of 15 offenses' do
exclusion_list = []
file_list = []
15.times do |index|
file_name = format('test_%02d.rb', index)
formatter.file_started(file_name, {})
formatter.file_finished(file_name, offenses)
file_list << file_name
exclusion_list << " - '#{file_name}'"
end
file_list << 'test.rb'
formatter.file_started('test.rb', {})
formatter.file_finished('test.rb', [offenses.first])
formatter.finished(file_list)
expect(output.string).to eq(format(described_class::HEADING,
'rubocop --auto-gen-config') +
['',
'',
'# Offense count: 16',
'Cop1:',
' Enabled: false',
'',
'# Offense count: 15',
'Cop2:',
' Exclude:',
exclusion_list,
''].flatten.join("\n"))
end
it 'creates a .rubocop_todo.yml even if RuboCop does not inspect ' \
'any files' do
formatter.finished([])
expect(output.string).to eq(format(described_class::HEADING,
'rubocop --auto-gen-config') +
"\n")
end
context 'when exclude_limit option is passed into constructor' do
let(:formatter) { described_class.new(output, exclude_limit: 5) }
it 'respects the exclusion list limit' do
exclusion_list = []
file_list = []
15.times do |index|
file_name = format('test_%02d.rb', index)
formatter.file_started(file_name, {})
formatter.file_finished(file_name, offenses)
file_list << file_name
exclusion_list << " - '#{file_name}'"
end
file_list << 'test.rb'
formatter.file_started('test.rb', {})
formatter.file_finished('test.rb', [offenses.first])
formatter.finished(file_list)
expect(output.string).to eq(format(described_class::HEADING,
'rubocop --auto-gen-config ' \
'--exclude-limit 5') +
['',
'',
'# Offense count: 16',
'Cop1:',
' Enabled: false',
'',
'# Offense count: 15',
'Cop2:',
' Enabled: false',
''].flatten.join("\n"))
end
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/formatter/disabled_lines_formatter_spec.rb 0000664 0000000 0000000 00000005075 13070542236 0030135 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module RuboCop
module Formatter
describe DisabledLinesFormatter do
subject(:formatter) { described_class.new(output) }
let(:output) { StringIO.new }
let(:files) do
%w[lib/rubocop.rb spec/spec_helper.rb bin/rubocop].map do |path|
File.expand_path(path)
end
end
let(:file_started) do
formatter.file_started(files.first, cop_disabled_line_ranges)
end
describe '#file_started' do
before { formatter.started(files) }
context 'when no disable cop comments are detected' do
let(:cop_disabled_line_ranges) { {} }
it 'does not add to cop_disabled_line_ranges' do
expect { file_started }.not_to(
change { formatter.cop_disabled_line_ranges }
)
end
end
context 'when any disable cop comments are detected' do
let(:cop_disabled_line_ranges) do
{ cop_disabled_line_ranges: { 'LineLength' => [1..1] } }
end
it 'merges the changes into cop_disabled_line_ranges' do
expect { file_started }.to(
change { formatter.cop_disabled_line_ranges }
)
end
end
end
describe '#finished' do
context 'when there disabled cops detected' do
let(:cop_disabled_line_ranges) do
{
cop_disabled_line_ranges: {
'LineLength' => [1..1],
'ClassLength' => [1..Float::INFINITY]
}
}
end
let(:offenses) do
[
Cop::Offense.new(:convention, location, 'Class too long.',
'ClassLength', :disabled),
Cop::Offense.new(:convention, location, 'Line too long.',
'LineLength', :uncorrected)
]
end
let(:location) { OpenStruct.new(line: 3) }
before do
formatter.started(files)
formatter.file_started('lib/rubocop.rb', cop_disabled_line_ranges)
formatter.file_finished('lib/rubocop.rb', offenses)
end
it 'lists disabled cops by file' do
formatter.finished(files)
expect(output.string)
.to eq(['',
'Cops disabled line ranges:',
'',
'lib/rubocop.rb:1..1: LineLength',
'lib/rubocop.rb:1..Infinity: ClassLength',
''].join("\n"))
end
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/formatter/emacs_style_formatter_spec.rb 0000664 0000000 0000000 00000005446 13070542236 0027506 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module RuboCop
module Formatter
describe EmacsStyleFormatter do
subject(:formatter) { described_class.new(output) }
let(:output) { StringIO.new }
describe '#file_finished' do
it 'displays parsable text' do
cop = Cop::Cop.new
source_buffer = Parser::Source::Buffer.new('test', 1)
source_buffer.source = %w[a b cdefghi].join("\n")
cop.add_offense(nil,
Parser::Source::Range.new(source_buffer, 0, 1),
'message 1')
cop.add_offense(nil,
Parser::Source::Range.new(source_buffer, 9, 10),
'message 2')
formatter.file_finished('test', cop.offenses)
expect(output.string).to eq ['test:1:1: C: message 1',
'test:3:6: C: message 2',
''].join("\n")
end
context 'when the offense is automatically corrected' do
let(:file) { '/path/to/file' }
let(:offense) do
Cop::Offense.new(:convention, location,
'This is a message.', 'CopName', status)
end
let(:location) do
source_buffer = Parser::Source::Buffer.new('test', 1)
source_buffer.source = "a\n"
Parser::Source::Range.new(source_buffer, 0, 1)
end
let(:status) { :corrected }
it 'prints [Corrected] along with message' do
formatter.file_finished(file, [offense])
expect(output.string)
.to include(': [Corrected] This is a message.')
end
end
context 'when the offense message contains a newline' do
let(:file) { '/path/to/file' }
let(:offense) do
Cop::Offense.new(:error, location,
"unmatched close parenthesis: /\n world " \
"# Some comment containing a )\n/",
'CopName', :uncorrected)
end
let(:location) do
source_buffer = Parser::Source::Buffer.new('test', 1)
source_buffer.source = "a\n"
Parser::Source::Range.new(source_buffer, 0, 1)
end
it 'strips newlines out of the error message' do
formatter.file_finished(file, [offense])
expect(output.string).to eq(
'/path/to/file:1:1: E: unmatched close parenthesis: / ' \
"world # Some comment containing a ) /\n"
)
end
end
end
describe '#finished' do
it 'does not report summary' do
formatter.finished(['/path/to/file'])
expect(output.string).to be_empty
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/formatter/file_list_formatter_spec.rb 0000664 0000000 0000000 00000001631 13070542236 0027140 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module RuboCop
module Formatter
describe FileListFormatter do
subject(:formatter) { described_class.new(output) }
let(:output) { StringIO.new }
describe '#file_finished' do
it 'displays parsable text' do
cop = Cop::Cop.new
source_buffer = Parser::Source::Buffer.new('test', 1)
source_buffer.source = %w[a b cdefghi].join("\n")
cop.add_offense(nil,
Parser::Source::Range.new(source_buffer, 0, 1),
'message 1')
cop.add_offense(nil,
Parser::Source::Range.new(source_buffer, 9, 10),
'message 2')
formatter.file_finished('test', cop.offenses)
formatter.file_finished('test_2', cop.offenses)
expect(output.string).to eq "test\ntest_2\n"
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/formatter/formatter_set_spec.rb 0000664 0000000 0000000 00000011122 13070542236 0025755 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module RuboCop
module Formatter
describe FormatterSet do
subject(:formatter_set) { described_class.new }
it 'responds to all formatter API methods' do
%i[started file_started file_finished finished].each do |method|
expect(formatter_set).to respond_to(method)
end
end
describe 'formatter API method' do
before do
formatter_set.add_formatter('simple')
formatter_set.add_formatter('emacs')
end
let(:files) { ['/path/to/file1', '/path/to/file2'] }
it 'invokes same method of all containing formatters' do
formatter_set.each do |formatter|
expect(formatter).to receive(:started).with(files)
end
formatter_set.started(files)
end
end
describe 'add_formatter' do
it 'adds a formatter to itself' do
formatter_set.add_formatter('simple')
expect(formatter_set.size).to eq(1)
end
it 'adds a formatter with specified formatter type' do
formatter_set.add_formatter('simple')
expect(formatter_set.first.class).to eq(SimpleTextFormatter)
end
it 'can add multiple formatters by being invoked multiple times' do
formatter_set.add_formatter('simple')
formatter_set.add_formatter('emacs')
expect(formatter_set[0].class).to eq(SimpleTextFormatter)
expect(formatter_set[1].class).to eq(EmacsStyleFormatter)
end
context 'when output path is omitted' do
it 'adds a formatter outputs to $stdout' do
formatter_set.add_formatter('simple')
expect(formatter_set.first.output).to eq($stdout)
end
end
context 'when output path is specified' do
it 'adds a formatter outputs to the specified file' do
output_path = Tempfile.new('').path
formatter_set.add_formatter('simple', output_path)
expect(formatter_set.first.output.class).to eq(File)
expect(formatter_set.first.output.path).to eq(output_path)
end
context "when parent directories don't exist" do
let(:tmpdir) { Dir.mktmpdir }
after { FileUtils.rm_rf(tmpdir) }
it 'creates them' do
output_path = File.join(tmpdir, 'path/does/not/exist')
formatter_set.add_formatter('simple', output_path)
expect(formatter_set.first.output.class).to eq(File)
expect(formatter_set.first.output.path).to eq(output_path)
end
end
end
end
describe '#close_output_files' do
before do
2.times do
output_path = Tempfile.new('').path
formatter_set.add_formatter('simple', output_path)
end
formatter_set.add_formatter('simple')
end
it 'closes all output files' do
formatter_set.close_output_files
formatter_set[0..1].each do |formatter|
expect(formatter.output).to be_closed
end
end
it 'does not close non file output' do
expect(formatter_set[2].output).not_to be_closed
end
end
describe '#builtin_formatter_class' do
def builtin_formatter_class(string)
described_class.new.send(:builtin_formatter_class, string)
end
it 'returns class which matches passed alias name exactly' do
expect(builtin_formatter_class('simple'))
.to eq(SimpleTextFormatter)
end
it 'returns class whose first letter of alias name ' \
'matches passed letter' do
expect(builtin_formatter_class('s'))
.to eq(SimpleTextFormatter)
end
end
describe '#custom_formatter_class' do
def custom_formatter_class(string)
described_class.new.send(:custom_formatter_class, string)
end
it 'returns constant represented by the passed string' do
expect(custom_formatter_class('RuboCop')).to eq(RuboCop)
end
it 'can handle namespaced constant name' do
expect(custom_formatter_class('RuboCop::CLI')).to eq(RuboCop::CLI)
end
it 'can handle top level namespaced constant name' do
expect(custom_formatter_class('::RuboCop::CLI')).to eq(RuboCop::CLI)
end
context 'when non-existent constant name is passed' do
it 'raises error' do
expect { custom_formatter_class('RuboCop::NonExistentClass') }
.to raise_error(NameError)
end
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/formatter/fuubar_style_formatter_spec.rb 0000664 0000000 0000000 00000006402 13070542236 0027673 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module RuboCop
describe Formatter::FuubarStyleFormatter do
subject(:formatter) { described_class.new(output) }
let(:output) { StringIO.new }
let(:files) do
%w[lib/rubocop.rb spec/spec_helper.rb].map do |path|
File.expand_path(path)
end
end
describe '#with_color' do
around do |example|
original_state = formatter.rainbow.enabled
begin
example.run
ensure
formatter.rainbow.enabled = original_state
end
end
context 'when color is enabled' do
before do
formatter.rainbow.enabled = true
end
it 'outputs coloring sequence code at the beginning and the end' do
formatter.with_color { formatter.output.write 'foo' }
expect(output.string).to eq("\e[32mfoo\e[0m")
end
end
context 'when color is enabled' do
before do
formatter.rainbow.enabled = false
end
it 'outputs nothing' do
formatter.with_color { formatter.output.write 'foo' }
expect(output.string).to eq('foo')
end
end
end
describe '#progressbar_color' do
before do
formatter.started(files)
end
def offense(severity, status = :uncorrected)
source_range = double('source_range').as_null_object
Cop::Offense.new(severity, source_range, 'message', 'Cop', status)
end
context 'initially' do
it 'is green' do
expect(formatter.progressbar_color).to eq(:green)
end
end
context 'when no offenses are detected in a file' do
before do
formatter.file_finished(files[0], [])
end
it 'is still green' do
expect(formatter.progressbar_color).to eq(:green)
end
end
context 'when a convention offense is detected in a file' do
before do
formatter.file_finished(files[0], [offense(:convention)])
end
it 'is yellow' do
expect(formatter.progressbar_color).to eq(:yellow)
end
end
context 'when an error offense is detected in a file' do
before do
formatter.file_finished(files[0], [offense(:error)])
end
it 'is red' do
expect(formatter.progressbar_color).to eq(:red)
end
context 'and then a convention offense is detected in the next file' do
before do
formatter.file_finished(files[1], [offense(:convention)])
end
it 'is still red' do
expect(formatter.progressbar_color).to eq(:red)
end
end
end
context 'when convention and error offenses are detected in a file' do
before do
offenses = [offense(:convention), offense(:error)]
formatter.file_finished(files[0], offenses)
end
it 'is red' do
expect(formatter.progressbar_color).to eq(:red)
end
end
context 'when a offense is detected in a file and auto-corrected' do
before do
formatter.file_finished(files[0], [offense(:convention, :corrected)])
end
it 'is green' do
expect(formatter.progressbar_color).to eq(:green)
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/formatter/html_formatter_spec.rb 0000664 0000000 0000000 00000003662 13070542236 0026140 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module RuboCop
module Formatter
describe HTMLFormatter, :isolated_environment do
spec_root = File.expand_path('../../..', __FILE__)
around do |example|
project_path = File.join(spec_root, 'fixtures/html_formatter/project')
FileUtils.cp_r(project_path, '.')
Dir.chdir(File.basename(project_path)) do
example.run
end
end
let(:actual_html_path) do
path = File.expand_path('result.html')
# Run without Style/EndOfLine as it gives different results on
# different platforms.
CLI.new.run(['--except', 'Style/EndOfLine', '--format', 'html',
'--out', path])
path
end
let(:actual_html_path_cached) do
path = File.expand_path('result_cached.html')
2.times do
CLI.new.run(['--except', 'Style/EndOfLine', '--format', 'html',
'--out', path])
end
path
end
let(:actual_html) do
File.read(actual_html_path, encoding: Encoding::UTF_8)
end
let(:actual_html_cached) do
File.read(actual_html_path_cached, encoding: Encoding::UTF_8)
end
let(:expected_html_path) do
File.join(spec_root, 'fixtures/html_formatter/expected.html')
end
let(:expected_html) do
html = File.read(expected_html_path, encoding: Encoding::UTF_8)
# Avoid failure on version bump
html.sub(/(class="version".{0,20})\d+(?:\.\d+){2}/i) do
Regexp.last_match(1) + RuboCop::Version::STRING
end
end
it 'outputs the result in HTML' do
# FileUtils.copy(actual_html_path, expected_html_path)
expect(actual_html).to eq(expected_html)
end
it 'outputs the cached result in HTML' do
# FileUtils.copy(actual_html_path, expected_html_path)
expect(actual_html_cached).to eq(expected_html)
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/formatter/json_formatter_spec.rb 0000664 0000000 0000000 00000010551 13070542236 0026140 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module RuboCop
describe Formatter::JSONFormatter do
subject(:formatter) { described_class.new(output) }
let(:output) { StringIO.new }
let(:files) { %w[/path/to/file1 /path/to/file2] }
let(:location) do
source_buffer = Parser::Source::Buffer.new('test', 1)
source_buffer.source = %w[a b cdefghi].join("\n")
Parser::Source::Range.new(source_buffer, 9, 10)
end
let(:offense) do
Cop::Offense.new(:convention, location,
'This is message', 'CopName', :corrected)
end
describe '#started' do
let(:summary) { formatter.output_hash[:summary] }
it 'sets target file count in summary' do
expect(summary[:target_file_count]).to be_nil
formatter.started(%w[/path/to/file1 /path/to/file2])
expect(summary[:target_file_count]).to eq(2)
end
end
describe '#file_finished' do
before do
count = 0
allow(formatter).to receive(:hash_for_file) do
count += 1
end
end
let(:summary) { formatter.output_hash[:summary] }
it 'adds detected offense count in summary' do
expect(summary[:offense_count]).to eq(0)
formatter.file_started(files[0], {})
expect(summary[:offense_count]).to eq(0)
formatter.file_finished(files[0], [
double('offense1'), double('offense2')
])
expect(summary[:offense_count]).to eq(2)
end
it 'adds value of #hash_for_file to #output_hash[:files]' do
expect(formatter.output_hash[:files]).to be_empty
formatter.file_started(files[0], {})
expect(formatter.output_hash[:files]).to be_empty
formatter.file_finished(files[0], [])
expect(formatter.output_hash[:files]).to eq([1])
formatter.file_started(files[1], {})
expect(formatter.output_hash[:files]).to eq([1])
formatter.file_finished(files[1], [])
expect(formatter.output_hash[:files]).to eq([1, 2])
end
end
describe '#finished' do
let(:summary) { formatter.output_hash[:summary] }
it 'sets inspected file count in summary' do
expect(summary[:inspected_file_count]).to be_nil
formatter.finished(%w[/path/to/file1 /path/to/file2])
expect(summary[:inspected_file_count]).to eq(2)
end
it 'outputs #output_hash as JSON' do
formatter.finished(files)
json = output.string
restored_hash = JSON.parse(json, symbolize_names: true)
expect(restored_hash).to eq(formatter.output_hash)
end
end
describe '#hash_for_file' do
subject(:hash) { formatter.hash_for_file(file, offenses) }
let(:file) { File.expand_path('spec/spec_helper.rb') }
let(:offenses) { [double('offense1'), double('offense2')] }
it 'sets relative file path for :path key' do
expect(hash[:path]).to eq('spec/spec_helper.rb')
end
before do
count = 0
allow(formatter).to receive(:hash_for_offense) do
count += 1
end
end
it 'sets an array of #hash_for_offense values for :offenses key' do
expect(hash[:offenses]).to eq([1, 2])
end
end
describe '#hash_for_offense' do
subject(:hash) { formatter.hash_for_offense(offense) }
it 'sets Offense#severity value for :severity key' do
expect(hash[:severity]).to eq(:convention)
end
it 'sets Offense#message value for :message key' do
expect(hash[:message]).to eq('This is message')
end
it 'sets Offense#cop_name value for :cop_name key' do
expect(hash[:cop_name]).to eq('CopName')
end
it 'sets Offense#corrected? value for :corrected key' do
expect(hash[:corrected]).to be_truthy
end
it 'sets value of #hash_for_location for :location key' do
location_hash = { line: 3, column: 6, length: 1 }
expect(hash[:location]).to eq(location_hash)
end
end
describe '#hash_for_location' do
subject(:hash) { formatter.hash_for_location(offense) }
it 'sets line value for :line key' do
expect(hash[:line]).to eq(3)
end
it 'sets column value for :column key' do
expect(hash[:column]).to eq(6)
end
it 'sets length value for :length key' do
expect(hash[:length]).to eq(1)
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/formatter/offense_count_formatter_spec.rb 0000664 0000000 0000000 00000004342 13070542236 0030025 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module RuboCop
module Formatter
describe OffenseCountFormatter do
subject(:formatter) { described_class.new(output) }
let(:output) { StringIO.new }
let(:files) do
%w[lib/rubocop.rb spec/spec_helper.rb bin/rubocop].map do |path|
File.expand_path(path)
end
end
let(:finish) { formatter.file_finished(files.first, offenses) }
describe '#file_finished' do
before { formatter.started(files) }
context 'when no offenses are detected' do
let(:offenses) { [] }
it 'does not add to offense_counts' do
expect { finish }.not_to change { formatter.offense_counts }
end
end
context 'when any offenses are detected' do
let(:offenses) { [double('offense', cop_name: 'OffendedCop')] }
it 'increments the count for the cop in offense_counts' do
expect { finish }.to change { formatter.offense_counts }
end
end
end
describe '#report_summary' do
context 'when an offense is detected' do
let(:cop_counts) { { 'OffendedCop' => 1 } }
it 'shows the cop and the offense count' do
formatter.report_summary(cop_counts)
expect(output.string).to include(
"\n1 OffendedCop\n--\n1 Total"
)
end
end
end
describe '#finished' do
context 'when there are many offenses' do
let(:offenses) do
%w[CopB CopA CopC CopC].map { |c| double('offense', cop_name: c) }
end
before do
formatter.started(files)
finish
end
it 'sorts by offense count first and then by cop name' do
formatter.finished(files)
expect(output.string).to eq(['',
'2 CopC',
'1 CopA',
'1 CopB',
'--',
'4 Total',
'',
''].join("\n"))
end
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/formatter/progress_formatter_spec.rb 0000664 0000000 0000000 00000012060 13070542236 0027030 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module RuboCop
describe Formatter::ProgressFormatter do
subject(:formatter) { described_class.new(output) }
let(:output) { StringIO.new }
let(:files) do
%w[lib/rubocop.rb spec/spec_helper.rb bin/rubocop].map do |path|
File.expand_path(path)
end
end
describe '#file_finished' do
before do
formatter.started(files)
formatter.file_started(files.first, {})
end
shared_examples 'calls #report_file_as_mark' do
it 'calls #report_as_with_mark' do
expect(formatter).to receive(:report_file_as_mark)
formatter.file_finished(files.first, offenses)
end
end
context 'when no offenses are detected' do
let(:offenses) { [] }
include_examples 'calls #report_file_as_mark'
end
context 'when any offenses are detected' do
let(:offenses) { [double('offense').as_null_object] }
include_examples 'calls #report_file_as_mark'
end
end
describe '#report_file_as_mark' do
before do
formatter.report_file_as_mark(offenses)
end
def offense_with_severity(severity)
source_buffer = Parser::Source::Buffer.new('test', 1)
source_buffer.source = "a\n"
Cop::Offense.new(severity,
Parser::Source::Range.new(source_buffer, 0, 1),
'message',
'CopName')
end
context 'when no offenses are detected' do
let(:offenses) { [] }
it 'prints "."' do
expect(output.string).to eq('.')
end
end
context 'when a refactor severity offense is detected' do
let(:offenses) { [offense_with_severity(:refactor)] }
it 'prints "R"' do
expect(output.string).to eq('R')
end
end
context 'when a refactor convention offense is detected' do
let(:offenses) { [offense_with_severity(:convention)] }
it 'prints "C"' do
expect(output.string).to eq('C')
end
end
context 'when different severity offenses are detected' do
let(:offenses) do
[
offense_with_severity(:refactor),
offense_with_severity(:error)
]
end
it 'prints highest level mark' do
expect(output.string).to eq('E')
end
end
end
describe '#finished' do
before do
formatter.started(files)
end
context 'when any offenses are detected' do
before do
source_buffer = Parser::Source::Buffer.new('test', 1)
source = Array.new(9) do |index|
"This is line #{index + 1}."
end
source_buffer.source = source.join("\n")
line_length = source[0].length + 1
formatter.file_started(files[0], {})
formatter.file_finished(
files[0],
[
Cop::Offense.new(
:convention,
Parser::Source::Range.new(source_buffer,
line_length + 2,
line_length + 3),
'foo',
'Cop'
)
]
)
formatter.file_started(files[1], {})
formatter.file_finished(files[1], [])
formatter.file_started(files[2], {})
formatter.file_finished(
files[2],
[
Cop::Offense.new(
:error,
Parser::Source::Range.new(source_buffer,
4 * line_length + 1,
4 * line_length + 2),
'bar',
'Cop'
),
Cop::Offense.new(
:convention,
Parser::Source::Range.new(source_buffer,
5 * line_length,
5 * line_length + 1),
'foo',
'Cop'
)
]
)
end
it 'reports all detected offenses for all failed files' do
formatter.finished(files)
expect(output.string).to include([
'Offenses:',
'',
'lib/rubocop.rb:2:3: C: foo',
'This is line 2.',
' ^',
'bin/rubocop:5:2: E: bar',
'This is line 5.',
' ^',
'bin/rubocop:6:1: C: foo',
'This is line 6.',
'^'
].join("\n"))
end
end
context 'when no offenses are detected' do
before do
files.each do |file|
formatter.file_started(file, {})
formatter.file_finished(file, [])
end
end
it 'does not report offenses' do
formatter.finished(files)
expect(output.string).not_to include('Offenses:')
end
end
it 'calls #report_summary' do
expect(formatter).to receive(:report_summary)
formatter.finished(files)
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/formatter/simple_text_formatter_spec.rb 0000664 0000000 0000000 00000010170 13070542236 0027521 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module RuboCop
module Formatter
describe SimpleTextFormatter do
before do
Rainbow.enabled = true
end
subject(:formatter) { described_class.new(output) }
let(:output) { StringIO.new }
describe '#report_file' do
before do
formatter.report_file(file, [offense])
end
let(:file) { '/path/to/file' }
let(:offense) do
Cop::Offense.new(:convention, location,
'This is a message with `colored text`.',
'CopName', status)
end
let(:location) do
source_buffer = Parser::Source::Buffer.new('test', 1)
source_buffer.source = "a\n"
Parser::Source::Range.new(source_buffer, 0, 1)
end
let(:status) { :uncorrected }
context 'the file is under the current working directory' do
let(:file) { File.expand_path('spec/spec_helper.rb') }
it 'prints as relative path' do
expect(output.string).to include('== spec/spec_helper.rb ==')
end
end
context 'the file is outside of the current working directory' do
let(:file) do
tempfile = Tempfile.new('')
tempfile.close
File.expand_path(tempfile.path)
end
it 'prints as absolute path' do
expect(output.string).to include("== #{file} ==")
end
end
context 'when the offense is not corrected' do
let(:status) { :uncorrected }
it 'prints message as-is' do
expect(output.string)
.to include(': This is a message with colored text.')
end
end
context 'when the offense is automatically corrected' do
let(:status) { :corrected }
it 'prints [Corrected] along with message' do
expect(output.string)
.to include(': [Corrected] This is a message with colored text.')
end
end
end
describe '#report_summary' do
context 'when no files inspected' do
it 'handles pluralization correctly' do
formatter.report_summary(0, 0, 0)
expect(output.string).to eq(
['',
'0 files inspected, no offenses detected',
''].join("\n")
)
end
end
context 'when a file inspected and no offenses detected' do
it 'handles pluralization correctly' do
formatter.report_summary(1, 0, 0)
expect(output.string).to eq(
['',
'1 file inspected, no offenses detected',
''].join("\n")
)
end
end
context 'when a offense detected' do
it 'handles pluralization correctly' do
formatter.report_summary(1, 1, 0)
expect(output.string).to eq(
['',
'1 file inspected, 1 offense detected',
''].join("\n")
)
end
end
context 'when 2 offenses detected' do
it 'handles pluralization correctly' do
formatter.report_summary(2, 2, 0)
expect(output.string).to eq(
['',
'2 files inspected, 2 offenses detected',
''].join("\n")
)
end
end
context 'when an offense is corrected' do
it 'prints about correction' do
formatter.report_summary(1, 1, 1)
expect(output.string).to eq(
['',
'1 file inspected, 1 offense detected, 1 offense corrected',
''].join("\n")
)
end
end
context 'when 2 offenses are corrected' do
it 'handles pluralization correctly' do
formatter.report_summary(1, 1, 2)
expect(output.string).to eq(
['',
'1 file inspected, 1 offense detected, 2 offenses corrected',
''].join("\n")
)
end
end
end
after do
Rainbow.enabled = false
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/formatter/text_util_spec.rb 0000664 0000000 0000000 00000002623 13070542236 0025126 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module RuboCop
module Formatter
describe TextUtil do
subject(:text_util) { RuboCop::Formatter::TextUtil }
describe 'pluralize' do
it 'will not change 0 to no' do
pluralized_text = text_util.pluralize(0, 'file')
expect(pluralized_text).to eq('0 files')
end
it 'will change 0 to no when configured' do
pluralized_text = text_util.pluralize(0, 'file', no_for_zero: true)
expect(pluralized_text).to eq('no files')
end
it 'will not pluralize 1' do
pluralized_text = text_util.pluralize(1, 'file')
expect(pluralized_text).to eq('1 file')
end
it 'will pluralize quantities greater than 1' do
pluralized_text = text_util.pluralize(3, 'file')
expect(pluralized_text).to eq('3 files')
end
it 'will pluralize fractions' do
pluralized_text = text_util.pluralize(0.5, 'file')
expect(pluralized_text).to eq('0.5 files')
end
it 'will pluralize -1' do
pluralized_text = text_util.pluralize(-1, 'file')
expect(pluralized_text).to eq('-1 files')
end
it 'will pluralize negative quantities less than -1' do
pluralized_text = text_util.pluralize(-2, 'file')
expect(pluralized_text).to eq('-2 files')
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/formatter/worst_offenders_formatter_spec.rb 0000664 0000000 0000000 00000002400 13070542236 0030372 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module RuboCop
module Formatter
describe WorstOffendersFormatter do
subject(:formatter) { described_class.new(output) }
let(:output) { StringIO.new }
let(:files) do
%w[lib/rubocop.rb spec/spec_helper.rb bin/rubocop].map do |path|
File.expand_path(path)
end
end
describe '#finished' do
context 'when there are many offenses' do
let(:offense) { double('offense') }
before do
formatter.started(files)
files.each_with_index do |file, index|
formatter.file_finished(file, [offense] * (index + 2))
end
end
it 'sorts by offense count first and then by cop name' do
formatter.finished(files)
expect(output.string).to eq(['',
'4 bin/rubocop',
'3 spec/spec_helper.rb',
'2 lib/rubocop.rb',
'--',
'9 Total',
'',
''].join("\n"))
end
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/magic_comment_spec.rb 0000664 0000000 0000000 00000010203 13070542236 0023675 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
RSpec.describe RuboCop::MagicComment do
shared_examples 'magic comment' do |comment, expectations = {}|
encoding = expectations[:encoding]
frozen_string = expectations[:frozen_string_literal]
it "returns #{encoding.inspect} for encoding when comment is #{comment}" do
expect(described_class.parse(comment).encoding).to eql(encoding)
end
it "returns #{frozen_string.inspect} for frozen_string_literal " \
"when comment is #{comment}" do
expect(described_class.parse(comment).frozen_string_literal)
.to eql(frozen_string)
end
end
include_examples 'magic comment', '#'
include_examples 'magic comment',
'# encoding: utf-8',
encoding: 'utf-8'
include_examples 'magic comment',
'# ENCODING: utf-8',
encoding: 'utf-8'
include_examples 'magic comment',
'# eNcOdInG: utf-8',
encoding: 'utf-8'
include_examples 'magic comment',
'# coding: utf-8',
encoding: 'utf-8'
include_examples 'magic comment',
'# incoding: utf-8'
include_examples 'magic comment',
'# encoding: stateless-iso-2022-jp-kddi',
encoding: 'stateless-iso-2022-jp-kddi'
include_examples 'magic comment',
'# frozen_string_literal: true',
frozen_string_literal: true
include_examples 'magic comment',
'# frozen_string_literal:true',
frozen_string_literal: true
include_examples 'magic comment',
'# frozen_string_literal: false',
frozen_string_literal: false
include_examples 'magic comment',
'# frozen-string-literal: true',
frozen_string_literal: true
include_examples 'magic comment',
'# FROZEN-STRING-LITERAL: true',
frozen_string_literal: true
include_examples 'magic comment',
'# fRoZeN-sTrInG_lItErAl: true',
frozen_string_literal: true
include_examples 'magic comment',
'# frozen_string_literal: invalid',
frozen_string_literal: 'invalid'
include_examples 'magic comment',
'# -*- encoding : ascii-8bit -*-',
encoding: 'ascii-8bit',
frozen_string_literal: nil
include_examples 'magic comment',
'# encoding: ascii-8bit frozen_string_literal: true',
encoding: 'ascii-8bit',
frozen_string_literal: nil
include_examples 'magic comment',
'# frozen_string_literal: true encoding: ascii-8bit',
encoding: 'ascii-8bit',
frozen_string_literal: nil
include_examples(
'magic comment',
'# -*- encoding: ASCII-8BIT; frozen_string_literal: true -*-',
encoding: 'ascii-8bit',
frozen_string_literal: true
)
include_examples(
'magic comment',
'# coding: utf-8 -*- encoding: ASCII-8BIT; frozen_string_literal: true -*-',
encoding: 'ascii-8bit',
frozen_string_literal: true
)
include_examples 'magic comment',
'# vim: filetype=ruby, fileencoding=ascii-8bit',
encoding: 'ascii-8bit'
include_examples 'magic comment',
'# vim: filetype=ruby,fileencoding=ascii-8bit',
encoding: nil
include_examples 'magic comment',
'# vim: filetype=ruby, fileencoding=ascii-8bit',
encoding: 'ascii-8bit'
include_examples 'magic comment',
'#vim: filetype=ruby, fileencoding=ascii-8bit',
encoding: 'ascii-8bit'
include_examples(
'magic comment',
'# coding: utf-8 vim: filetype=ruby, fileencoding=ascii-8bit',
encoding: 'utf-8'
)
include_examples 'magic comment',
'# vim: filetype=python, fileencoding=ascii-8bit',
encoding: 'ascii-8bit'
include_examples 'magic comment',
'# vim:fileencoding=utf-8',
encoding: nil
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/node_pattern_spec.rb 0000664 0000000 0000000 00000062777 13070542236 0023604 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'parser/current'
describe RuboCop::NodePattern do
let(:root_node) do
buffer = Parser::Source::Buffer.new('(string)', 1)
buffer.source = ruby
builder = RuboCop::AST::Builder.new
Parser::CurrentRuby.new(builder).parse(buffer)
end
let(:node) { root_node }
let(:params) { [] }
shared_examples :matching do
include RuboCop::AST::Sexp
it 'matches' do
expect(described_class.new(pattern).match(node, *params)).to be true
end
end
shared_examples :nonmatching do
it "doesn't match" do
expect(described_class.new(pattern).match(node, *params)).to be_nil
end
end
shared_examples :invalid do
it 'is invalid' do
expect { described_class.new(pattern) }
.to raise_error(RuboCop::NodePattern::Invalid)
end
end
shared_examples :single_capture do
include RuboCop::AST::Sexp
it 'yields captured value(s) and returns true if there is a block' do
expect do |probe|
compiled = described_class.new(pattern)
retval = compiled.match(node, *params) do |capture|
probe.to_proc.call(capture)
:retval_from_block
end
expect(retval).to be :retval_from_block
end.to yield_with_args(captured_val)
end
it 'returns captured values if there is no block' do
retval = described_class.new(pattern).match(node, *params)
expect(retval).to eq captured_val
end
end
shared_examples :multiple_capture do
include RuboCop::AST::Sexp
it 'yields captured value(s) and returns true if there is a block' do
expect do |probe|
compiled = described_class.new(pattern)
retval = compiled.match(node, *params) do |*captures|
probe.to_proc.call(captures)
:retval_from_block
end
expect(retval).to be :retval_from_block
end.to yield_with_args(captured_vals)
end
it 'returns captured values if there is no block' do
retval = described_class.new(pattern).match(node, *params)
expect(retval).to eq captured_vals
end
end
describe 'bare node type' do
let(:pattern) { 'send' }
context 'on a node with the same type' do
let(:ruby) { 'obj.method' }
it_behaves_like :matching
end
context 'on a node with a different type' do
let(:ruby) { '@ivar' }
it_behaves_like :nonmatching
end
context 'on a node with a matching, hyphenated type' do
let(:pattern) { 'op-asgn' }
let(:ruby) { 'a += 1' } # this is an (op-asgn ...) node
it_behaves_like :matching
end
end
describe 'literals' do
context 'negative integer literals' do
let(:pattern) { '(int -100)' }
let(:ruby) { '-100' }
it_behaves_like :matching
end
context 'positive float literals' do
let(:pattern) { '(float 1.0)' }
let(:ruby) { '1.0' }
it_behaves_like :matching
end
context 'negative float literals' do
let(:pattern) { '(float -2.5)' }
let(:ruby) { '-2.5' }
it_behaves_like :matching
end
end
describe 'simple sequence' do
let(:pattern) { '(send int :+ int)' }
context 'on a node with the same type and matching children' do
let(:ruby) { '1 + 1' }
it_behaves_like :matching
end
context 'on a node with a different type' do
let(:ruby) { 'a = 1' }
it_behaves_like :nonmatching
end
context 'on a node with the same type and non-matching children' do
context 'with non-matching selector' do
let(:ruby) { '1 - 1' }
it_behaves_like :nonmatching
end
context 'with non-matching receiver type' do
let(:ruby) { '1.0 + 1' }
it_behaves_like :nonmatching
end
end
context 'on a node with too many children' do
let(:pattern) { '(send int :blah int)' }
let(:ruby) { '1.blah(1, 2)' }
it_behaves_like :nonmatching
end
context 'with a nested sequence in head position' do
let(:pattern) { '((send) int :blah)' }
it_behaves_like :invalid
end
context 'with a nested sequence in non-head position' do
let(:pattern) { '(send (send _ :a) :b)' }
let(:ruby) { 'obj.a.b' }
it_behaves_like :matching
end
end
describe 'sequence with trailing ...' do
let(:pattern) { '(send int :blah ...)' }
context 'on a node with the same type and exact number of children' do
let(:ruby) { '1.blah' }
it_behaves_like :matching
end
context 'on a node with the same type and more children' do
context 'with 1 child more' do
let(:ruby) { '1.blah(1)' }
it_behaves_like :matching
end
context 'with 2 children more' do
let(:ruby) { '1.blah(1, :something)' }
it_behaves_like :matching
end
end
context 'on a node with the same type and fewer children' do
let(:pattern) { '(send int :blah int int ...)' }
let(:ruby) { '1.blah(2)' }
it_behaves_like :nonmatching
end
context 'on a node with fewer children, with a wildcard preceding' do
let(:pattern) { '(hash _ ...)' }
let(:ruby) { '{}' }
it_behaves_like :nonmatching
end
context 'on a node with a different type' do
let(:ruby) { 'A = 1' }
it_behaves_like :nonmatching
end
context 'on a node with non-matching children' do
let(:ruby) { '1.foo' }
it_behaves_like :nonmatching
end
end
describe 'wildcards' do
describe 'unnamed wildcards' do
context 'at the root level' do
let(:pattern) { '_' }
let(:ruby) { 'class << self; def something; 1; end end.freeze' }
it_behaves_like :matching
end
context 'within a sequence' do
let(:pattern) { '(const _ _)' }
let(:ruby) { 'Const' }
it_behaves_like :matching
end
context 'within a sequence with other patterns intervening' do
let(:pattern) { '(ivasgn _ (int _))' }
let(:ruby) { '@abc = 22' }
it_behaves_like :matching
end
context 'in head position of a sequence' do
let(:pattern) { '(_ int ...)' }
let(:ruby) { '1 + a' }
it_behaves_like :matching
end
context 'negated' do
let(:pattern) { '!_' }
let(:ruby) { '123' }
it_behaves_like :nonmatching
end
end
describe 'named wildcards' do
# unification is done on named wildcards!
context 'at the root level' do
let(:pattern) { '_node' }
let(:ruby) { 'class << self; def something; 1; end end.freeze' }
it_behaves_like :matching
end
context 'within a sequence' do
context 'with values which can be unified' do
let(:pattern) { '(send _num :+ _num)' }
let(:ruby) { '5 + 5' }
it_behaves_like :matching
end
context 'with values which cannot be unified' do
let(:pattern) { '(send _num :+ _num)' }
let(:ruby) { '5 + 4' }
it_behaves_like :nonmatching
end
context 'unifying the node type with an argument' do
let(:pattern) { '(_type _ _type)' }
let(:ruby) { 'obj.send' }
it_behaves_like :matching
end
end
context 'within a sequence with other patterns intervening' do
let(:pattern) { '(ivasgn _ivar (int _val))' }
let(:ruby) { '@abc = 22' }
it_behaves_like :matching
end
context 'in head position of a sequence' do
let(:pattern) { '(_type int ...)' }
let(:ruby) { '1 + a' }
it_behaves_like :matching
end
end
end
describe 'sets' do
context 'at the top level' do
context 'containing symbol literals' do
context 'when the AST has a matching symbol' do
let(:pattern) { '(send _ {:a :b})' }
let(:ruby) { 'obj.b' }
it_behaves_like :matching
end
context 'when the AST does not have a matching symbol' do
let(:pattern) { '(send _ {:a :b})' }
let(:ruby) { 'obj.c' }
it_behaves_like :nonmatching
end
end
context 'containing integer literals' do
let(:pattern) { '(send (int {1 10}) :abs)' }
let(:ruby) { '10.abs' }
it_behaves_like :matching
end
context 'containing multiple []' do
let(:pattern) { '{[(int odd?) int] [!nil float]}' }
context 'on a node which meets all requirements of the first []' do
let(:ruby) { '3' }
it_behaves_like :matching
end
context 'on a node which meets all requirements of the second []' do
let(:ruby) { '2.2' }
it_behaves_like :matching
end
context 'on a node which meets some requirements but not all' do
let(:ruby) { '2' }
it_behaves_like :nonmatching
end
end
end
context 'nested inside a sequence' do
let(:pattern) { '(send {const int} ...)' }
let(:ruby) { 'Const.method' }
it_behaves_like :matching
end
context 'with a nested sequence' do
let(:pattern) { '{(send int ...) (send const ...)}' }
let(:ruby) { 'Const.method' }
it_behaves_like :matching
end
end
describe 'captures on a wildcard' do
context 'at the root level' do
let(:pattern) { '$_' }
let(:ruby) { 'begin; raise StandardError; rescue Exception => e; end' }
let(:captured_val) { node }
it_behaves_like :single_capture
end
context 'in head position in a sequence' do
let(:pattern) { '($_ ...)' }
let(:ruby) { 'A.method' }
let(:captured_val) { :send }
it_behaves_like :single_capture
end
context 'in non-head position in a sequence' do
let(:pattern) { '(send $_ ...)' }
let(:ruby) { 'A.method' }
let(:captured_val) { s(:const, nil, :A) }
it_behaves_like :single_capture
end
context 'in a nested sequence' do
let(:pattern) { '(send (const nil $_) ...)' }
let(:ruby) { 'A.method' }
let(:captured_val) { :A }
it_behaves_like :single_capture
end
end
describe 'captures which also perform a match' do
context 'on a sequence' do
let(:pattern) { '(send $(send _ :keys) :each)' }
let(:ruby) { '{}.keys.each' }
let(:captured_val) { s(:send, s(:hash), :keys) }
it_behaves_like :single_capture
end
context 'on a set' do
let(:pattern) { '(send _ ${:inc :dec})' }
let(:ruby) { '1.dec' }
let(:captured_val) { :dec }
it_behaves_like :single_capture
end
context 'on []' do
let(:pattern) { '(send (int $[!odd? !zero?]) :inc)' }
let(:ruby) { '2.inc' }
let(:captured_val) { 2 }
it_behaves_like :single_capture
end
context 'on a node type' do
let(:pattern) { '(send $int :inc)' }
let(:ruby) { '5.inc' }
let(:captured_val) { s(:int, 5) }
it_behaves_like :single_capture
end
context 'on a literal' do
let(:pattern) { '(send int $:inc)' }
let(:ruby) { '5.inc' }
let(:captured_val) { :inc }
it_behaves_like :single_capture
end
context 'when nested' do
let(:pattern) { '(send $(int $_) :inc)' }
let(:ruby) { '5.inc' }
let(:captured_vals) { [s(:int, 5), 5] }
it_behaves_like :multiple_capture
end
end
describe 'captures on ...' do
context 'with no remaining pattern at the end' do
let(:pattern) { '(send $...)' }
let(:ruby) { '5.inc' }
let(:captured_val) { [s(:int, 5), :inc] }
it_behaves_like :single_capture
end
context 'with a remaining node type at the end' do
let(:pattern) { '(send $... int)' }
let(:ruby) { '5 + 4' }
let(:captured_val) { [s(:int, 5), :+] }
it_behaves_like :single_capture
end
context 'with a remaining sequence at the end' do
let(:pattern) { '(send $... (int 4))' }
let(:ruby) { '5 + 4' }
let(:captured_val) { [s(:int, 5), :+] }
it_behaves_like :single_capture
end
context 'with a remaining set at the end' do
let(:pattern) { '(send $... {int float})' }
let(:ruby) { '5 + 4' }
let(:captured_val) { [s(:int, 5), :+] }
it_behaves_like :single_capture
end
context 'with a remaining [] at the end' do
let(:pattern) { '(send $... [(int even?) (int zero?)])' }
let(:ruby) { '5 + 0' }
let(:captured_val) { [s(:int, 5), :+] }
it_behaves_like :single_capture
end
context 'with a remaining literal at the end' do
let(:pattern) { '(send $... :inc)' }
let(:ruby) { '5.inc' }
let(:captured_val) { [s(:int, 5)] }
it_behaves_like :single_capture
end
context 'with a remaining wildcard at the end' do
let(:pattern) { '(send $... _)' }
let(:ruby) { '5.inc' }
let(:captured_val) { [s(:int, 5)] }
it_behaves_like :single_capture
end
context 'with a remaining capture at the end' do
let(:pattern) { '(send $... $_)' }
let(:ruby) { '5 + 4' }
let(:captured_vals) { [[s(:int, 5), :+], s(:int, 4)] }
it_behaves_like :multiple_capture
end
context 'at the very beginning of a sequence' do
let(:pattern) { '($... (int 1))' }
let(:ruby) { '10 * 1' }
let(:captured_val) { [s(:int, 10), :*] }
it_behaves_like :single_capture
end
end
describe 'captures within sets' do
context 'on simple subpatterns' do
let(:pattern) { '{$send $int $float}' }
let(:ruby) { '2.0' }
let(:captured_val) { s(:float, 2.0) }
it_behaves_like :single_capture
end
context 'within nested sequences' do
let(:pattern) { '{(send $_ $_) (const $_ $_)}' }
let(:ruby) { 'Namespace::CONST' }
let(:captured_vals) { [s(:const, nil, :Namespace), :CONST] }
it_behaves_like :multiple_capture
end
context 'with complex nesting' do
let(:pattern) do
'{(send {$int $float} {$:inc $:dec}) ' \
'[!nil {($_ sym $_) (send ($_ $_) :object_id)}]}'
end
let(:ruby) { '10.object_id' }
let(:captured_vals) { [:int, 10] }
it_behaves_like :multiple_capture
end
context 'with a different number of captures in each branch' do
let(:pattern) { '{(send $...) (int $...) (send $_ $_)}' }
it_behaves_like :invalid
end
end
describe 'negation' do
context 'on a symbol' do
let(:pattern) { '(send _ !:abc)' }
context 'with a matching symbol' do
let(:ruby) { 'obj.abc' }
it_behaves_like :nonmatching
end
context 'with a non-matching symbol' do
let(:ruby) { 'obj.xyz' }
it_behaves_like :matching
end
context 'with a non-matching symbol, but too many children' do
let(:ruby) { 'obj.xyz(1)' }
it_behaves_like :nonmatching
end
end
context 'on a set' do
let(:pattern) { '(ivasgn _ !(int {1 2}))' }
context 'with a matching value' do
let(:ruby) { '@a = 1' }
it_behaves_like :nonmatching
end
context 'with a non-matching value' do
let(:ruby) { '@a = 3' }
it_behaves_like :matching
end
end
context 'on a sequence' do
let(:pattern) { '!(ivasgn :@a ...)' }
context 'with a matching node' do
let(:ruby) { '@a = 1' }
it_behaves_like :nonmatching
end
context 'with a node of different type' do
let(:ruby) { '@@a = 1' }
it_behaves_like :matching
end
context 'with a node with non-matching children' do
let(:ruby) { '@b = 1' }
it_behaves_like :matching
end
end
context 'on square brackets' do
let(:pattern) { '![!int !float]' }
context 'with a node which meets all requirements of []' do
let(:ruby) { '"abc"' }
it_behaves_like :nonmatching
end
context 'with a node which meets only 1 requirement of []' do
let(:ruby) { '1' }
it_behaves_like :matching
end
end
context 'when nested in complex ways' do
let(:pattern) { '!(send !{int float} !:+ !(send _ :to_i))' }
context 'with (send str :+ (send str :to_i))' do
let(:ruby) { '"abc" + "1".to_i' }
it_behaves_like :matching
end
context 'with (send int :- int)' do
let(:ruby) { '1 - 1' }
it_behaves_like :matching
end
context 'with (send str :<< str)' do
let(:ruby) { '"abc" << "xyz"' }
it_behaves_like :nonmatching
end
end
end
describe 'ellipsis' do
context 'preceding a capture' do
let(:pattern) { '(send array :push ... $_)' }
let(:ruby) { '[1].push(2, 3, 4)' }
let(:captured_val) { s(:int, 4) }
it_behaves_like :single_capture
end
context 'with a wildcard at the end, but no remaining child to match it' do
let(:pattern) { '(send array :zip array ... _)' }
let(:ruby) { '[1,2].zip([3,4])' }
it_behaves_like :nonmatching
end
context 'with a nodetype at the end, but no remaining child to match it' do
let(:pattern) { '(send array :zip array ... array)' }
let(:ruby) { '[1,2].zip([3,4])' }
it_behaves_like :nonmatching
end
context 'with a nested sequence at the end, but no remaining child' do
let(:pattern) { '(send array :zip array ... (array ...))' }
let(:ruby) { '[1,2].zip([3,4])' }
it_behaves_like :nonmatching
end
context 'with a set at the end, but no remaining child to match it' do
let(:pattern) { '(send array :zip array ... {array})' }
let(:ruby) { '[1,2].zip([3,4])' }
it_behaves_like :nonmatching
end
context 'with [] at the end, but no remaining child to match it' do
let(:pattern) { '(send array :zip array ... [array !nil])' }
let(:ruby) { '[1,2].zip([3,4])' }
it_behaves_like :nonmatching
end
context 'at the very beginning of a sequence' do
let(:pattern) { '(... (int 1))' }
let(:ruby) { '10 * 1' }
it_behaves_like :matching
end
end
describe 'predicates' do
context 'in root position' do
let(:pattern) { 'send_type?' }
let(:ruby) { '1.inc' }
it_behaves_like :matching
end
context 'at head position of a sequence' do
# called on the type symbol
let(:pattern) { '(!nil? int ...)' }
let(:ruby) { '1.inc' }
it_behaves_like :matching
end
context 'applied to an integer for which the predicate is true' do
let(:pattern) { '(send (int odd?) :inc)' }
let(:ruby) { '1.inc' }
it_behaves_like :matching
end
context 'applied to an integer for which the predicate is false' do
let(:pattern) { '(send (int odd?) :inc)' }
let(:ruby) { '2.inc' }
it_behaves_like :nonmatching
end
context 'when captured' do
let(:pattern) { '(send (int $odd?) :inc)' }
let(:ruby) { '1.inc' }
let(:captured_val) { 1 }
it_behaves_like :single_capture
end
context 'when negated' do
let(:pattern) { '(send int !nil?)' }
let(:ruby) { '1.inc' }
it_behaves_like :matching
end
context 'when in last-child position, but all children have already ' \
'been matched' do
let(:pattern) { '(send int :inc ... !nil?)' }
let(:ruby) { '1.inc' }
it_behaves_like :nonmatching
end
context 'with one extra argument' do
let(:pattern) { '(send (int equal?(%1)) ...)' }
let(:ruby) { '1 + 2' }
context 'for which the predicate is true' do
let(:params) { [1] }
it_behaves_like :matching
end
context 'for which the predicate is false' do
let(:params) { [2] }
it_behaves_like :nonmatching
end
end
end
describe 'params' do
context 'in root position' do
let(:pattern) { '%1' }
let(:params) { [s(:int, 10)] }
let(:ruby) { '10' }
it_behaves_like :matching
end
context 'in a nested sequence' do
let(:pattern) { '(send (send _ %2) %1)' }
let(:params) { %i[inc dec] }
let(:ruby) { '5.dec.inc' }
it_behaves_like :matching
end
context 'when preceded by ...' do
let(:pattern) { '(send ... %1)' }
let(:params) { [s(:int, 10)] }
let(:ruby) { '1 + 10' }
it_behaves_like :matching
end
context 'when preceded by $...' do
let(:pattern) { '(send $... %1)' }
let(:params) { [s(:int, 10)] }
let(:ruby) { '1 + 10' }
let(:captured_val) { [s(:int, 1), :+] }
it_behaves_like :single_capture
end
context 'when captured' do
let(:pattern) { '(const _ $%1)' }
let(:params) { [:A] }
let(:ruby) { 'Namespace::A' }
let(:captured_val) { :A }
it_behaves_like :single_capture
end
context 'when negated, with a matching value' do
let(:pattern) { '(const _ !%1)' }
let(:params) { [:A] }
let(:ruby) { 'Namespace::A' }
it_behaves_like :nonmatching
end
context 'when negated, with a nonmatching value' do
let(:pattern) { '(const _ !%1)' }
let(:params) { [:A] }
let(:ruby) { 'Namespace::B' }
it_behaves_like :matching
end
context 'without explicit number' do
let(:pattern) { '(const %2 %)' }
let(:params) { [:A, s(:const, nil, :Namespace)] }
let(:ruby) { 'Namespace::A' }
it_behaves_like :matching
end
context 'when inside a union, with a matching value' do
let(:pattern) { '{str (int %)}' }
let(:params) { [10] }
let(:ruby) { '10' }
it_behaves_like :matching
end
context 'when inside a union, with a nonmatching value' do
let(:pattern) { '{str (int %)}' }
let(:params) { [10] }
let(:ruby) { '1.0' }
it_behaves_like :nonmatching
end
context 'when inside an intersection' do
let(:pattern) { '(int [!%1 %2 !zero?])' }
let(:params) { [10, 20] }
let(:ruby) { '20' }
it_behaves_like :matching
end
context 'param number zero' do
# refers to original target node passed to #match
let(:pattern) { '^(send %0 :+ (int 2))' }
let(:ruby) { '1 + 2' }
context 'in a position which matches original target node' do
let(:node) { root_node.children[0] }
it_behaves_like :matching
end
context 'in a position which does not match original target node' do
let(:node) { root_node.children[2] }
it_behaves_like :nonmatching
end
end
end
describe 'caret (ascend)' do
context 'used with a node type' do
let(:ruby) { '1.inc' }
let(:node) { root_node.children[0] }
context 'which matches' do
let(:pattern) { '^send' }
it_behaves_like :matching
end
context "which doesn't match" do
let(:pattern) { '^const' }
it_behaves_like :nonmatching
end
end
context 'repeated twice' do
# ascends to grandparent node
let(:pattern) { '^^block' }
let(:ruby) { '1.inc { something }' }
let(:node) { root_node.children[0].children[0] }
it_behaves_like :matching
end
context 'inside an intersection' do
let(:pattern) { '^[!nil send ^(block ...)]' }
let(:ruby) { '1.inc { something }' }
let(:node) { root_node.children[0].children[0] }
it_behaves_like :matching
end
context 'inside a union' do
let(:pattern) { '{^send ^^send}' }
let(:ruby) { '"str".concat(local += "abc")' }
let(:node) { root_node.children[2].children[2] }
it_behaves_like :matching
end
# NOTE!! a pitfall of doing this is that unification is done using #==
# This means that 'identical' AST nodes, which are not really identical
# because they have different metadata, will still unify
context 'using unification to match self within parent' do
let(:pattern) { '[_self ^(send _ _ _self)]' }
let(:ruby) { '1 + 2' }
context 'with self in the right position' do
let(:node) { root_node.children[2] }
it_behaves_like :matching
end
context 'with self in the wrong position' do
let(:node) { root_node.children[0] }
it_behaves_like :nonmatching
end
end
end
describe 'funcalls' do
module RuboCop
class NodePattern
def goodmatch(_arg1)
true
end
def badmatch(_arg1)
false
end
def witharg(_arg1, arg2)
arg2
end
def withargs(_arg1, _arg2, arg3)
arg3
end
end
end
context 'without extra arguments' do
let(:pattern) { '(lvasgn #goodmatch ...)' }
let(:ruby) { 'a = 1' }
it_behaves_like :matching
end
end
describe 'commas' do
# commas are just whitespace
context 'with commas randomly strewn around' do
let(:pattern) { ',,(,send,, ,int,:+, int ), ' }
let(:ruby) { '1 + 2' }
it_behaves_like :matching
end
end
describe 'bad syntax' do
context 'with empty parentheses' do
let(:pattern) { '()' }
it_behaves_like :invalid
end
context 'with unmatched opening paren' do
let(:pattern) { '(send (const)' }
it_behaves_like :invalid
end
context 'with unmatched closing paren' do
let(:pattern) { '(send (const)))' }
it_behaves_like :invalid
end
context 'with unmatched opening curly' do
let(:pattern) { '{send const' }
it_behaves_like :invalid
end
context 'with unmatched closing curly' do
let(:pattern) { '{send const}}' }
it_behaves_like :invalid
end
context 'with negated closing paren' do
let(:pattern) { '(send (const) !)' }
it_behaves_like :invalid
end
context 'with negated closing curly' do
let(:pattern) { '{send const !}' }
it_behaves_like :invalid
end
context 'with negated ellipsis' do
let(:pattern) { '(send !...)' }
it_behaves_like :invalid
end
context 'with doubled ellipsis' do
let(:pattern) { '(send ... ...)' }
it_behaves_like :invalid
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/options_spec.rb 0000664 0000000 0000000 00000027511 13070542236 0022600 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Options, :isolated_environment do
include FileHelper
subject(:options) { described_class.new }
before do
$stdout = StringIO.new
$stderr = StringIO.new
end
after do
$stdout = STDOUT
$stderr = STDERR
end
def abs(path)
File.expand_path(path)
end
describe 'option' do
describe '-h/--help' do
it 'exits cleanly' do
expect { options.parse ['-h'] }.to exit_with_code(0)
expect { options.parse ['--help'] }.to exit_with_code(0)
end
it 'shows help text' do
begin
options.parse(['--help'])
rescue SystemExit # rubocop:disable Lint/HandleExceptions
end
expected_help = <<-END.strip_indent
Usage: rubocop [options] [file1, file2, ...]
-L, --list-target-files List all files RuboCop will inspect.
--except [COP1,COP2,...] Disable the given cop(s).
--only [COP1,COP2,...] Run only the given cop(s).
--only-guide-cops Run only cops for rules that link to a
style guide.
-c, --config FILE Specify configuration file.
--auto-gen-config Generate a configuration file acting as a
TODO list.
--exclude-limit COUNT Used together with --auto-gen-config to
set the limit for how many Exclude
properties to generate. Default is 15.
--force-exclusion Force excluding files specified in the
configuration `Exclude` even if they are
explicitly passed as arguments.
--force-default-config Use default configuration even if configuration
files are present in the directory tree.
--no-offense-counts Do not include offense counts in configuration
file generated by --auto-gen-config.
-f, --format FORMATTER Choose an output formatter. This option
can be specified multiple times to enable
multiple formatters at the same time.
[p]rogress (default)
[s]imple
[c]lang
[d]isabled cops via inline comments
[fu]ubar
[e]macs
[j]son
[h]tml
[fi]les
[o]ffenses
[w]orst
custom formatter class name
-o, --out FILE Write output to a file instead of STDOUT.
This option applies to the previously
specified --format, or the default format
if no format is specified.
-r, --require FILE Require Ruby file.
--fail-level SEVERITY Minimum severity (A/R/C/W/E/F) for exit
with error code.
--show-cops [COP1,COP2,...] Shows the given cops, or all cops by
default, and their configurations for the
current directory.
-F, --fail-fast Inspect files in order of modification
time and stop after the first file
containing offenses.
-C, --cache FLAG Use result caching (FLAG=true) or don't
(FLAG=false), default determined by
configuration parameter AllCops: UseCache.
-d, --debug Display debug info.
-D, --display-cop-names Display cop names in offense messages.
-E, --extra-details Display extra details in offense messages.
-S, --display-style-guide Display style guide URLs in offense messages.
-R, --rails Run extra Rails cops.
-l, --lint Run only lint cops.
-a, --auto-correct Auto-correct offenses.
--[no-]color Force color output on or off.
-v, --version Display version.
-V, --verbose-version Display verbose version.
-s, --stdin FILE Pipe source from STDIN, using FILE in offense
reports. This is useful for editor integration.
END
expect($stdout.string).to eq(expected_help)
end
it 'lists all builtin formatters' do
begin
options.parse(['--help'])
rescue SystemExit # rubocop:disable Lint/HandleExceptions
end
option_sections = $stdout.string.lines.slice_before(/^\s*-/)
format_section = option_sections.find do |lines|
lines.first =~ /^\s*-f/
end
formatter_keys = format_section.reduce([]) do |keys, line|
match = line.match(/^[ ]{39}(\[[a-z\]]+)/)
next keys unless match
keys << match.captures.first.gsub(/\[|\]/, '')
end.sort
expected_formatter_keys =
RuboCop::Formatter::FormatterSet::BUILTIN_FORMATTERS_FOR_KEYS
.keys.sort
expect(formatter_keys).to eq(expected_formatter_keys)
end
end
describe 'incompatible cli options' do
it 'rejects using -v with -V' do
msg = 'Incompatible cli options: [:version, :verbose_version]'
expect { options.parse %w[-vV] }
.to raise_error(ArgumentError, msg)
end
it 'rejects using -v with --show-cops' do
msg = 'Incompatible cli options: [:version, :show_cops]'
expect { options.parse %w[-v --show-cops] }
.to raise_error(ArgumentError, msg)
end
it 'rejects using -V with --show-cops' do
msg = 'Incompatible cli options: [:verbose_version, :show_cops]'
expect { options.parse %w[-V --show-cops] }
.to raise_error(ArgumentError, msg)
end
it 'mentions all incompatible options when more than two are used' do
msg = ['Incompatible cli options: [:version, :verbose_version,',
' :show_cops]'].join
expect { options.parse %w[-vV --show-cops] }
.to raise_error(ArgumentError, msg)
end
end
describe '--fail-level' do
it 'accepts full severity names' do
%w[refactor convention warning error fatal].each do |severity|
expect { options.parse(['--fail-level', severity]) }
.not_to raise_error
end
end
it 'accepts severity initial letters' do
%w[R C W E F].each do |severity|
expect { options.parse(['--fail-level', severity]) }
.not_to raise_error
end
end
it 'accepts the "fake" severities A/autocorrect' do
%w[autocorrect A].each do |severity|
expect { options.parse(['--fail-level', severity]) }
.not_to raise_error
end
end
end
describe '--require' do
let(:required_file_path) { './path/to/required_file.rb' }
before do
create_file('example.rb', '# encoding: utf-8')
create_file(required_file_path, "puts 'Hello from required file!'")
end
it 'requires the passed path' do
options.parse(['--require', required_file_path, 'example.rb'])
expect($stdout.string).to start_with('Hello from required file!')
end
end
describe '--cache' do
it 'fails if no argument is given' do
expect { options.parse %w[--cache] }
.to raise_error(OptionParser::MissingArgument)
end
it 'fails if unrecognized argument is given' do
expect { options.parse %w[--cache maybe] }.to raise_error(ArgumentError)
end
it 'accepts true as argument' do
expect { options.parse %w[--cache true] }.not_to raise_error
end
it 'accepts false as argument' do
expect { options.parse %w[--cache false] }.not_to raise_error
end
end
describe '--exclude-limit' do
it 'fails if given last without argument' do
expect { options.parse %w[--auto-gen-config --exclude-limit] }
.to raise_error(OptionParser::MissingArgument)
end
it 'fails if given alone without argument' do
expect { options.parse %w[--exclude-limit] }
.to raise_error(OptionParser::MissingArgument)
end
it 'fails if given first without argument' do
expect { options.parse %w[--exclude-limit --auto-gen-config] }
.to raise_error(OptionParser::MissingArgument)
end
it 'fails if given without --auto-gen-config' do
expect { options.parse %w[--exclude-limit 10] }
.to raise_error(ArgumentError)
end
end
describe '--auto-gen-config' do
it 'accepts other options' do
expect { options.parse %w[--auto-gen-config --rails] }
.not_to raise_error
end
end
describe '-s/--stdin' do
before do
$stdin = StringIO.new
$stdin.puts("{ foo: 'bar' }")
$stdin.rewind
end
it 'fails if no paths are given' do
expect { options.parse %w[-s] }
.to raise_error(OptionParser::MissingArgument)
end
it 'succeeds with exactly one path' do
expect { options.parse %w[--stdin foo] }.not_to raise_error
end
it 'fails if more than one path is given' do
expect { options.parse %w[--stdin foo bar] }
.to raise_error(ArgumentError)
end
end
end
describe 'options precedence' do
def with_env_options(options)
ENV['RUBOCOP_OPTS'] = options
yield
ensure
ENV.delete('RUBOCOP_OPTS')
end
let(:command_line_options) { %w[--no-color] }
subject { options.parse(command_line_options).first }
context '.rubocop file' do
before do
create_file('.rubocop', %w[--color --fail-level C])
end
it 'has lower precedence then command line options' do
is_expected.to eq(color: false, fail_level: :convention)
end
it 'has lower precedence then options from RUBOCOP_OPTS env variable' do
with_env_options '--fail-level W' do
is_expected.to eq(color: false, fail_level: :warning)
end
end
end
context '.rubocop directory' do
before do
FileUtils.mkdir '.rubocop'
end
it 'is ignored and command line options are used' do
is_expected.to eq(color: false)
end
end
context 'RUBOCOP_OPTS environment variable' do
it 'has lower precedence then command line options' do
with_env_options '--color' do
is_expected.to eq(color: false)
end
end
it 'has higher precedence then options from .rubocop file' do
create_file('.rubocop', %w[--color --fail-level C])
with_env_options '--fail-level W' do
is_expected.to eq(color: false, fail_level: :warning)
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/path_util_spec.rb 0000664 0000000 0000000 00000006070 13070542236 0023073 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::PathUtil do
describe '#relative_path' do
it 'builds paths relative to PWD by default as a stop-gap' do
relative = File.join(Dir.pwd, 'relative')
expect(described_class.relative_path(relative)).to eq('relative')
end
it 'supports custom base paths' do
expect(described_class.relative_path('/foo/bar', '/foo')).to eq('bar')
end
end
describe '#match_path?', :isolated_environment do
include FileHelper
before do
create_file('file', '')
create_file('dir/file', '')
create_file('dir/files', '')
create_file('dir/dir/file', '')
create_file('dir/sub/file', '')
create_file('dir/.hidden/file', '')
create_file('dir/.hidden_file', '')
$stderr = StringIO.new
end
after { $stderr = STDERR }
it 'does not match dir/** for file in hidden dir' do
expect(described_class.match_path?('dir/**', 'dir/.hidden/file'))
.to be_falsey
expect($stderr.string).to eq('')
end
it 'does not match dir/** for hidden file' do
expect(described_class.match_path?('dir/**', 'dir/.hidden_file'))
.to be_falsey
expect($stderr.string).to eq('')
end
it 'does not match file in a subdirectory' do
expect(described_class.match_path?('file', 'dir/files')).to be_falsey
expect(described_class.match_path?('dir', 'dir/file')).to be_falsey
end
it 'matches strings to the full path' do
expect(described_class.match_path?("#{Dir.pwd}/dir/file",
"#{Dir.pwd}/dir/file")).to be_truthy
expect(described_class.match_path?(
"#{Dir.pwd}/dir/file",
"#{Dir.pwd}/dir/dir/file"
)).to be_falsey
end
it 'matches glob expressions' do
expect(described_class.match_path?('dir/*', 'dir/file')).to be_truthy
expect(described_class.match_path?('dir/*/*',
'dir/sub/file')).to be_truthy
expect(described_class.match_path?('dir/**/*',
'dir/sub/file')).to be_truthy
expect(described_class.match_path?('dir/**/*', 'dir/file')).to be_truthy
expect(described_class.match_path?('**/*', 'dir/sub/file')).to be_truthy
expect(described_class.match_path?('**/file', 'file')).to be_truthy
expect(described_class.match_path?('sub/*', 'dir/sub/file')).to be_falsey
expect(described_class.match_path?('**/*',
'dir/.hidden/file')).to be_falsey
expect(described_class.match_path?('**/*',
'dir/.hidden_file')).to be_falsey
expect(described_class.match_path?('**/.*/*', 'dir/.hidden/file'))
.to be_truthy
expect(described_class.match_path?('**/.*',
'dir/.hidden_file')).to be_truthy
end
it 'matches regexps' do
expect(described_class.match_path?(/^d.*e$/, 'dir/file')).to be_truthy
expect(described_class.match_path?(/^d.*e$/, 'dir/filez')).to be_falsey
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/processed_source_spec.rb 0000664 0000000 0000000 00000013533 13070542236 0024453 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::ProcessedSource do
include FileHelper
subject(:processed_source) { described_class.new(source, ruby_version, path) }
let(:ruby_version) { RuboCop::Config::KNOWN_RUBIES.last }
let(:source) { <<-END.strip_indent }
# encoding: utf-8
def some_method
puts 'foo'
end
some_method
END
let(:path) { 'path/to/file.rb' }
describe '.from_file', :isolated_environment do
describe 'when the file exists' do
before do
create_file(path, 'foo')
end
let(:processed_source) { described_class.from_file(path, ruby_version) }
it 'returns an instance of ProcessedSource' do
expect(processed_source).to be_a(described_class)
end
it "sets the file path to the instance's #path" do
expect(processed_source.path).to eq(path)
end
end
it 'raises RuboCop::Error when the file does not exist' do
expect do
described_class.from_file('foo', ruby_version)
end.to raise_error(RuboCop::Error)
.with_message(/No such file or directory/)
end
end
describe '#path' do
it 'is the path passed to .new' do
expect(processed_source.path).to eq(path)
end
end
describe '#buffer' do
it 'is a source buffer' do
expect(processed_source.buffer).to be_a(Parser::Source::Buffer)
end
end
describe '#ast' do
it 'is the root node of AST' do
expect(processed_source.ast).to be_a(RuboCop::AST::Node)
end
end
describe '#comments' do
it 'is an array of comments' do
expect(processed_source.comments).to be_a(Array)
expect(processed_source.comments.first).to be_a(Parser::Source::Comment)
end
end
describe '#tokens' do
it 'has an array of tokens' do
expect(processed_source.tokens).to be_a(Array)
expect(processed_source.tokens.first).to be_a(RuboCop::Token)
end
end
shared_context 'invalid encoding source' do
let(:source) do
[
'# encoding: utf-8',
"# \xf9"
].join("\n")
end
end
describe '#parser_error' do
context 'when the source was properly parsed' do
it 'is nil' do
expect(processed_source.parser_error).to be_nil
end
end
context 'when the source lacks encoding comment and is really utf-8 ' \
'encoded but has been read as US-ASCII' do
let(:source) do
# When files are read into RuboCop, the encoding of source code
# lacking an encoding comment will default to the external encoding,
# which could for example be US-ASCII if the LC_ALL environment
# variable is set to "C".
'号码 = 3'.dup.force_encoding('US-ASCII')
end
it 'is nil' do
# ProcessedSource#parse sets UTF-8 as default encoding, so no error.
expect(processed_source.parser_error).to be_nil
end
end
context 'when the source could not be parsed due to encoding error' do
include_context 'invalid encoding source'
it 'returns the error' do
expect(processed_source.parser_error).to be_a(Exception)
expect(processed_source.parser_error.message)
.to include('invalid byte sequence')
end
end
end
describe '#lines' do
it 'is an array' do
expect(processed_source.lines).to be_a(Array)
end
it 'has same number of elements as line count' do
# Since the source has a trailing newline, there is a final empty line
expect(processed_source.lines.size).to eq(6)
end
it 'contains lines as string without linefeed' do
first_line = processed_source.lines.first
expect(first_line).to eq('# encoding: utf-8')
end
end
describe '#[]' do
context 'when an index is passed' do
it 'returns the line' do
expect(processed_source[3]).to eq('end')
end
end
context 'when a range is passed' do
it 'returns the array of lines' do
expect(processed_source[3..4]).to eq(%w[end some_method])
end
end
context 'when start index and length are passed' do
it 'returns the array of lines' do
expect(processed_source[3, 2]).to eq(%w[end some_method])
end
end
end
describe 'valid_syntax?' do
subject { processed_source.valid_syntax? }
context 'when the source is completely valid' do
let(:source) { 'def valid_code; end' }
it 'returns true' do
expect(processed_source.diagnostics).to be_empty
expect(processed_source).to be_valid_syntax
end
end
context 'when the source is invalid' do
let(:source) { 'def invalid_code; en' }
it 'returns false' do
expect(processed_source).not_to be_valid_syntax
end
end
context 'when the source is valid but has some warning diagnostics' do
let(:source) { 'do_something *array' }
it 'returns true' do
expect(processed_source.diagnostics).not_to be_empty
expect(processed_source.diagnostics.first.level).to eq(:warning)
expect(processed_source).to be_valid_syntax
end
end
context 'when the source could not be parsed due to encoding error' do
include_context 'invalid encoding source'
it 'returns false' do
expect(processed_source).not_to be_valid_syntax
end
end
# https://github.com/whitequark/parser/issues/283
context 'when the source itself is valid encoding but includes strange ' \
'encoding literals that are accepted by MRI' do
let(:source) do
'p "\xff"'
end
it 'returns true' do
expect(processed_source.diagnostics).to be_empty
expect(processed_source).to be_valid_syntax
end
end
context 'when a line starts with an integer literal' do
let(:source) { '1 + 1' }
# regression test
it 'tokenizes the source correctly' do
expect(processed_source.tokens[0].text).to eq '1'
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/rake_task_spec.rb 0000664 0000000 0000000 00000011111 13070542236 0023036 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'support/file_helper'
require 'rubocop/rake_task'
describe RuboCop::RakeTask do
include FileHelper
describe 'defining tasks' do
it 'creates a rubocop task' do
described_class.new
expect(Rake::Task.task_defined?(:rubocop)).to be true
end
it 'creates a rubocop:auto_correct task' do
described_class.new
expect(Rake::Task.task_defined?('rubocop:auto_correct')).to be true
end
it 'creates a named task' do
described_class.new(:lint_lib)
expect(Rake::Task.task_defined?(:lint_lib)).to be true
end
it 'creates an auto_correct task for the named task' do
described_class.new(:lint_lib)
expect(Rake::Task.task_defined?('lint_lib:auto_correct')).to be true
end
end
describe 'running tasks' do
before do
$stdout = StringIO.new
$stderr = StringIO.new
Rake::Task['rubocop'].clear if Rake::Task.task_defined?('rubocop')
end
after do
$stdout = STDOUT
$stderr = STDERR
end
it 'runs with default options' do
described_class.new
cli = double('cli', run: 0)
allow(RuboCop::CLI).to receive(:new) { cli }
expect(cli).to receive(:run).with([])
Rake::Task['rubocop'].execute
end
it 'runs with specified options if a block is given' do
described_class.new do |task|
task.patterns = ['lib/**/*.rb']
task.formatters = ['files']
task.fail_on_error = false
task.options = ['--display-cop-names']
task.verbose = false
end
cli = double('cli', run: 0)
allow(RuboCop::CLI).to receive(:new) { cli }
options = ['--format', 'files', '--display-cop-names', 'lib/**/*.rb']
expect(cli).to receive(:run).with(options)
Rake::Task['rubocop'].execute
end
it 'allows nested arrays inside formatters, options, and requires' do
described_class.new do |task|
task.formatters = [['files']]
task.requires = [['library']]
task.options = [['--display-cop-names']]
end
cli = double('cli', run: 0)
allow(RuboCop::CLI).to receive(:new) { cli }
options = ['--format', 'files', '--require', 'library',
'--display-cop-names']
expect(cli).to receive(:run).with(options)
Rake::Task['rubocop'].execute
end
it 'will not error when result is not 0 and fail_on_error is false' do
described_class.new do |task|
task.fail_on_error = false
end
cli = double('cli', run: 1)
allow(RuboCop::CLI).to receive(:new) { cli }
expect { Rake::Task['rubocop'].execute }.not_to raise_error
end
it 'exits when result is not 0 and fail_on_error is true' do
described_class.new
cli = double('cli', run: 1)
allow(RuboCop::CLI).to receive(:new) { cli }
expect { Rake::Task['rubocop'].execute }.to raise_error(SystemExit)
end
it 'uses the default formatter from .rubocop.yml if no formatter ' \
'option is given', :isolated_environment do
create_file('.rubocop.yml', ['AllCops:',
' DefaultFormatter: offenses'])
create_file('test.rb', '$:')
described_class.new do |task|
task.options = ['test.rb']
end
expect { Rake::Task['rubocop'].execute }.to raise_error(SystemExit)
expect($stdout.string.strip).to eq(['Running RuboCop...',
'',
'1 Style/SpecialGlobalVars',
'--',
'1 Total'].join("\n"))
expect($stderr.string.strip).to eq 'RuboCop failed!'
end
context 'auto_correct' do
it 'runs with --auto-correct' do
described_class.new
cli = double('cli', run: 0)
allow(RuboCop::CLI).to receive(:new) { cli }
options = ['--auto-correct']
expect(cli).to receive(:run).with(options)
Rake::Task['rubocop:auto_correct'].execute
end
it 'runs with with the options that were passed to its parent task' do
described_class.new do |task|
task.patterns = ['lib/**/*.rb']
task.formatters = ['files']
task.fail_on_error = false
task.options = ['-D']
task.verbose = false
end
cli = double('cli', run: 0)
allow(RuboCop::CLI).to receive(:new) { cli }
options = ['--auto-correct', '--format', 'files', '-D', 'lib/**/*.rb']
expect(cli).to receive(:run).with(options)
Rake::Task['rubocop:auto_correct'].execute
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/remote_config_spec.rb 0000664 0000000 0000000 00000004262 13070542236 0023723 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::RemoteConfig do
include FileHelper
let(:remote_config_url) { 'http://example.com/rubocop.yml' }
let(:base_dir) { '.' }
let(:cached_file_name) { '.rubocop-http---example-com-rubocop-yml' }
let(:cached_file_path) { File.expand_path(cached_file_name, base_dir) }
subject(:remote_config) do
described_class.new(remote_config_url, base_dir).file
end
before do
stub_request(:get, remote_config_url)
.to_return(status: 200, body: "Style/Encoding:\n Enabled: true")
end
after do
File.unlink cached_file_path if File.exist? cached_file_path
end
describe '.file' do
it 'downloads the file if the file does not exist' do
expect(remote_config).to eq(cached_file_path)
expect(File.exist?(cached_file_path)).to be_truthy
end
it 'does not download the file if cache lifetime has not been reached' do
FileUtils.touch cached_file_path, mtime: Time.now - ((60 * 60) * 20)
expect(remote_config).to eq(cached_file_path)
assert_not_requested :get, remote_config_url
end
it 'downloads the file if cache lifetime has been reached' do
FileUtils.touch cached_file_path, mtime: Time.now - ((60 * 60) * 30)
expect(remote_config).to eq(cached_file_path)
assert_requested :get, remote_config_url
end
context 'when the remote URL responds with redirect' do
let(:new_location) { 'http://cdn.example.com/rubocop.yml' }
before do
stub_request(:get, remote_config_url)
.to_return(headers: { 'Location' => new_location })
stub_request(:get, new_location)
.to_return(status: 200, body: "Style/Encoding:\n Enabled: true")
end
it 'follows the redirect and downloads the file' do
expect(remote_config).to eq(cached_file_path)
expect(File.exist?(cached_file_path)).to be_truthy
end
end
context 'when the remote URL responds with 500' do
before do
stub_request(:get, remote_config_url)
.to_return(status: 500)
end
it 'raises error' do
expect do
remote_config
end.to raise_error(Net::HTTPFatalError)
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/result_cache_spec.rb 0000664 0000000 0000000 00000015220 13070542236 0023540 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::ResultCache, :isolated_environment do
include FileHelper
subject(:cache) do
described_class.new(file, options, config_store, cache_root)
end
let(:file) { 'example.rb' }
let(:options) { {} }
let(:config_store) { double('config_store', for: RuboCop::Config.new) }
let(:cache_root) { "#{Dir.pwd}/rubocop_cache" }
let(:offenses) do
[RuboCop::Cop::Offense.new(:warning, location, 'unused var',
'Lint/UselessAssignment')]
end
let(:location) do
source_buffer = Parser::Source::Buffer.new(file)
source_buffer.read
Parser::Source::Range.new(source_buffer, 0, 2)
end
def abs(path)
File.expand_path(path)
end
before do
create_file('example.rb', ['# Hello',
'x = 1'])
allow(config_store).to receive(:for).with('example.rb')
.and_return(RuboCop::Config.new)
end
describe 'cached result that was saved with no command line option' do
shared_examples 'valid' do
it 'is valid and can be loaded' do
cache.save(offenses)
cache2 = described_class.new(file, options2, config_store, cache_root)
expect(cache2.valid?).to eq(true)
saved_offenses = cache2.load
expect(saved_offenses).to eq(offenses)
end
end
context 'when no option is given' do
let(:options2) { {} }
include_examples 'valid'
context 'when file contents have changed' do
it 'is invalid' do
cache.save(offenses)
create_file('example.rb', ['x = 2'])
cache2 = described_class.new(file, options, config_store, cache_root)
expect(cache2.valid?).to eq(false)
end
end
context 'when a symlink is present in the cache location' do
let(:cache2) do
described_class.new(file, options, config_store, cache_root)
end
let(:attack_target_dir) { Dir.mktmpdir }
before do
# Avoid getting "symlink() function is unimplemented on this
# machine" on Windows.
if RuboCop::Platform.windows?
skip 'Symlinks not implemented on Windows'
end
cache.save(offenses)
Find.find(cache_root) do |path|
next unless File.basename(path) == '_'
FileUtils.rm_rf(path)
FileUtils.ln_s(attack_target_dir, path)
end
$stderr = StringIO.new
end
after do
FileUtils.rmdir(attack_target_dir)
$stderr = STDERR
end
context 'and symlink attack protection is enabled' do
it 'prevents caching and prints a warning' do
cache2.save(offenses)
# The cache file has not been created because there was a symlink in
# its path.
expect(cache2.valid?).to eq(false)
expect($stderr.string)
.to match(/Warning: .* is a symlink, which is not allowed.\n/)
end
end
context 'and symlink attack protection is disabled' do
before do
allow(config_store).to receive(:for).with('.').and_return(
RuboCop::Config.new(
'AllCops' => {
'AllowSymlinksInCacheRootDirectory' => true
}
)
)
end
it 'permits caching and prints no warning' do
cache2.save(offenses)
expect(cache2.valid?).to eq(true)
expect($stderr.string)
.not_to match(/Warning: .* is a symlink, which is not allowed.\n/)
end
end
end
end
context 'when --format is given' do
let(:options2) { { format: 'simple' } }
include_examples 'valid'
end
context 'when --only is given' do
it 'is invalid' do
cache.save(offenses)
cache2 = described_class.new(file, { only: ['Metrics/LineLength'] },
config_store, cache_root)
expect(cache2.valid?).to eq(false)
end
end
context 'when --display-cop-names is given' do
it 'is invalid' do
cache.save(offenses)
cache2 = described_class.new(file, { display_cop_names: true },
config_store, cache_root)
expect(cache2.valid?).to eq(false)
end
end
context 'when a cache source is read' do
it 'has utf8 encoding' do
cache.save(offenses)
result = cache.load
loaded_encoding = result[0].location.source.encoding
expect(loaded_encoding).to eql(Encoding::UTF_8)
end
end
end
describe '#save' do
context 'when the default internal encoding is UTF-8' do
let(:offenses) do
[RuboCop::Cop::Offense.new(:warning, location, "unused var \xF0",
'Lint/UselessAssignment')]
end
before { Encoding.default_internal = Encoding::UTF_8 }
after { Encoding.default_internal = nil }
it 'writes non UTF-8 encodable data to file with no exception' do
cache.save(offenses)
end
end
end
describe '.cleanup' do
before do
cfg = RuboCop::Config.new('AllCops' => { 'MaxFilesInCache' => 1 })
allow(config_store).to receive(:for).with('.').and_return(cfg)
allow(config_store).to receive(:for).with('other.rb').and_return(cfg)
create_file('other.rb', ['x = 1'])
$stdout = StringIO.new
end
after do
$stdout = STDOUT
end
it 'removes the oldest files in the cache if needed' do
cache.save(offenses)
cache2 = described_class.new('other.rb', options, config_store,
cache_root)
expect(Dir["#{cache_root}/*/_/*"].size).to eq(1)
cache.class.cleanup(config_store, :verbose, cache_root)
expect($stdout.string).to eq('')
cache2.save(offenses)
underscore_dir = Dir["#{cache_root}/*/_"].first
expect(Dir["#{underscore_dir}/*"].size).to eq(2)
cache.class.cleanup(config_store, :verbose, cache_root)
expect(File.exist?(underscore_dir)).to be_falsey
expect($stdout.string)
.to eq("Removing the 2 oldest files from #{cache_root}\n")
end
end
context 'the cache path when using a temp directory' do
let(:config_store) { double('config_store') }
let(:tmpdir) { File.realpath(Dir.tmpdir) }
let(:puid) { Process.uid.to_s }
before do
allow(config_store).to receive(:for).with('.').and_return(
RuboCop::Config.new('AllCops' => { 'CacheRootDirectory' => '/tmp' })
)
end
it 'contains the process uid' do
cacheroot = RuboCop::ResultCache.cache_root(config_store)
expect(cacheroot).to eq(File.join(tmpdir, puid, 'rubocop_cache'))
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/runner_spec.rb 0000664 0000000 0000000 00000007655 13070542236 0022425 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module RuboCop
class Runner
attr_writer :errors # Needed only for testing.
end
end
describe RuboCop::Runner, :isolated_environment do
include FileHelper
let(:formatter_output_path) { 'formatter_output.txt' }
let(:formatter_output) { File.read(formatter_output_path) }
before do
create_file('example.rb', source)
end
describe '#run' do
let(:options) { { formatters: [['progress', formatter_output_path]] } }
subject(:runner) { described_class.new(options, RuboCop::ConfigStore.new) }
context 'if there are no offenses in inspected files' do
let(:source) { <<-END.strip_indent }
# coding: utf-8
def valid_code; end
END
it 'returns true' do
expect(runner.run([])).to be true
end
end
context 'if there is an offense in an inspected file' do
let(:source) { <<-END.strip_indent }
# coding: utf-8
def INVALID_CODE; end
END
it 'returns false' do
expect(runner.run([])).to be false
end
it 'sends the offense to a formatter' do
runner.run([])
expect(formatter_output).to eq <<-END.strip_indent
Inspecting 1 file
C
Offenses:
example.rb:3:5: C: Use snake_case for method names.
def INVALID_CODE; end
^^^^^^^^^^^^
1 file inspected, 1 offense detected
END
end
end
context 'if a cop crashes' do
before do
# The cache responds that it's not valid, which means that new results
# should normally be collected and saved...
cache = double('cache', 'valid?' => false)
# ... but there's a crash in one cop.
runner.errors = ['An error occurred in ...']
allow(RuboCop::ResultCache).to receive(:new) { cache }
end
let(:source) { '' }
it 'does not call ResultCache#save' do
# The double doesn't define #save, so we'd get an error if it were
# called.
runner.run([])
end
end
context 'if -s/--stdin is used with an offense' do
before do
# Make Style/EndOfLine give same output regardless of platform.
create_file('.rubocop.yml', ['Style/EndOfLine:',
' EnforcedStyle: lf'])
end
let(:options) do
{
formatters: [['progress', formatter_output_path]],
stdin: <<-END.strip_indent
# coding: utf-8
def INVALID_CODE; end
END
}
end
let(:source) { '' }
it 'returns false' do
expect(runner.run([])).to be false
end
it 'sends the offense to a formatter' do
runner.run([])
expect(formatter_output).to eq <<-END.strip_indent
Inspecting 1 file
C
Offenses:
example.rb:3:5: C: Use snake_case for method names.
def INVALID_CODE; end
^^^^^^^^^^^^
1 file inspected, 1 offense detected
END
end
end
end
describe '#run with cops autocorrecting each-other' do
let(:options) do
{
auto_correct: true,
formatters: [['progress', formatter_output_path]]
}
end
subject(:runner) do
runner_class = Class.new(RuboCop::Runner) do
def mobilized_cop_classes(_config)
RuboCop::Cop::Registry.new(
[
RuboCop::Cop::Test::ClassMustBeAModuleCop,
RuboCop::Cop::Test::ModuleMustBeAClassCop
]
)
end
end
runner_class.new(options, RuboCop::ConfigStore.new)
end
context 'if there is an offense in an inspected file' do
let(:source) { <<-END.strip_indent }
# coding: utf-8
class Klass
end
END
it 'aborts because of an infinite loop' do
expect do
runner.run([])
end.to raise_error RuboCop::Runner::InfiniteCorrectionLoop
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/string_interpreter_spec.rb 0000664 0000000 0000000 00000002225 13070542236 0025031 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::StringInterpreter do
describe '.interpret' do
shared_examples 'simple escape' do |escaped|
it "handles #{escaped}" do
expect(described_class.interpret(escaped)).to eq escaped[1..-1]
end
end
it 'handles hex' do
expect(described_class.interpret('\\\\x68')).to eq('\x68')
end
it 'handles octal' do
expect(described_class.interpret('\\\\150')).to eq('\150')
end
it 'handles unicode' do
expect(described_class.interpret('\\\\u0068')).to eq('\u0068')
end
it 'handles extended unicode' do
expect(described_class.interpret('\\\\u{0068 0068}'))
.to eq('\\u{0068 0068}')
end
it_behaves_like 'simple escape', '\\\\a'
it_behaves_like 'simple escape', '\\\\b'
it_behaves_like 'simple escape', '\\\\e'
it_behaves_like 'simple escape', '\\\\f'
it_behaves_like 'simple escape', '\\\\n'
it_behaves_like 'simple escape', '\\\\r'
it_behaves_like 'simple escape', '\\\\s'
it_behaves_like 'simple escape', '\\\\t'
it_behaves_like 'simple escape', '\\\\v'
it_behaves_like 'simple escape', '\\\\n'
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/string_util_spec.rb 0000664 0000000 0000000 00000002614 13070542236 0023445 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module RuboCop
module StringUtil
describe Jaro do
{
%w[foo foo] => 1.000,
%w[foo bar] => 0.000,
%w[martha marhta] => 0.944,
%w[dwayne duane] => 0.822
}.each do |strings, expected|
context "with #{strings.first.inspect} and #{strings.last.inspect}" do
subject(:distance) { Jaro.distance(*strings) }
it "returns #{expected}" do
expect(distance).to be_within(0.001).of(expected)
end
end
end
end
describe JaroWinkler do
# These samples are derived from Apache Lucene project.
# https://github.com/apache/lucene-solr/blob/lucene_solr_4_9_0/lucene/suggest/src/test/org/apache/lucene/search/spell/TestJaroWinklerDistance.java
{
%w[al al] => 1.000,
%w[martha marhta] => 0.961,
%w[jones johnson] => 0.832,
%w[abcvwxyz cabvwxyz] => 0.958,
%w[dwayne duane] => 0.840,
%w[dixon dicksonx] => 0.813,
%w[fvie ten] => 0.000
}.each do |strings, expected|
context "with #{strings.first.inspect} and #{strings.last.inspect}" do
subject(:distance) { JaroWinkler.distance(*strings) }
it "returns #{expected}" do
expect(distance).to be_within(0.001).of(expected)
end
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/target_finder_spec.rb 0000664 0000000 0000000 00000020163 13070542236 0023716 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::TargetFinder, :isolated_environment do
include FileHelper
subject(:target_finder) do
described_class.new(config_store, options)
end
let(:config_store) { RuboCop::ConfigStore.new }
let(:options) { { force_exclusion: force_exclusion, debug: debug } }
let(:force_exclusion) { false }
let(:debug) { false }
before do
create_file('dir1/ruby1.rb', '# encoding: utf-8')
create_file('dir1/ruby2.rb', '# encoding: utf-8')
create_file('dir1/file.txt', '# encoding: utf-8')
create_file('dir1/file', '# encoding: utf-8')
create_file('dir1/executable', '#!/usr/bin/env ruby')
create_file('dir2/ruby3.rb', '# encoding: utf-8')
end
describe '#find' do
let(:found_files) { target_finder.find(args) }
let(:found_basenames) { found_files.map { |f| File.basename(f) } }
let(:args) { [] }
it 'returns absolute paths' do
expect(found_files).not_to be_empty
found_files.each do |file|
expect(file.sub(/^[A-Z]:/, '')).to start_with('/')
end
end
context 'when no argument is passed' do
let(:args) { [] }
it 'finds files under the current directory' do
Dir.chdir('dir1') do
expect(found_files).not_to be_empty
found_files.each do |file|
expect(file).to include('/dir1/')
expect(file).not_to include('/dir2/')
end
end
end
end
context 'when a directory path is passed' do
let(:args) { ['../dir2'] }
it 'finds files under the specified directory' do
Dir.chdir('dir1') do
expect(found_files).not_to be_empty
found_files.each do |file|
expect(file).to include('/dir2/')
expect(file).not_to include('/dir1/')
end
end
end
end
context 'when a non-ruby file is passed' do
let(:args) { ['dir2/file'] }
it "doesn't pick the file" do
expect(found_basenames).to be_empty
end
end
context 'when files with a ruby extension are passed' do
let(:args) { RuboCop::RUBY_EXTENSIONS.map { |ext| "dir2/file#{ext}" } }
it 'picks all the ruby files' do
expect(found_basenames).to eq(
RuboCop::RUBY_EXTENSIONS.map { |ext| "file#{ext}" }
)
end
end
context 'when a file with a ruby filename is passed' do
let(:args) { RuboCop::RUBY_FILENAMES.map { |name| "dir2/#{name}" } }
it 'picks all the ruby files' do
expect(found_basenames).to eq(RuboCop::RUBY_FILENAMES)
end
end
context 'when files with ruby interpreters are passed' do
let(:args) { RuboCop::RUBY_INTERPRETERS.map { |name| "dir2/#{name}" } }
before do
RuboCop::RUBY_INTERPRETERS.each do |interpreter|
create_file("dir2/#{interpreter}", "#!/usr/bin/#{interpreter}")
end
end
it 'picks all the ruby files' do
expect(found_basenames).to eq(RuboCop::RUBY_INTERPRETERS)
end
end
context 'when a pattern is passed' do
let(:args) { ['dir1/*2.rb'] }
it 'finds files which match the pattern' do
expect(found_basenames).to eq(['ruby2.rb'])
end
end
context 'when same paths are passed' do
let(:args) { %w[dir1 dir1] }
it 'does not return duplicated file paths' do
count = found_basenames.count { |f| f == 'ruby1.rb' }
expect(count).to eq(1)
end
end
context 'when some paths are specified in the configuration Exclude ' \
'and they are explicitly passed as arguments' do
before do
create_file('.rubocop.yml', [
'AllCops:',
' Exclude:',
' - dir1/ruby1.rb',
" - 'dir2/*'"
])
create_file('dir1/.rubocop.yml', [
'AllCops:',
' Exclude:',
' - executable'
])
end
let(:args) do
['dir1/ruby1.rb', 'dir1/ruby2.rb', 'dir1/exe*', 'dir2/ruby3.rb']
end
context 'normally' do
it 'does not exclude them' do
expect(found_basenames)
.to eq(['ruby1.rb', 'ruby2.rb', 'executable', 'ruby3.rb'])
end
end
context "when it's forced to adhere file exclusion configuration" do
let(:force_exclusion) { true }
it 'excludes them' do
expect(found_basenames).to eq(['ruby2.rb'])
end
end
end
end
describe '#find_files' do
let(:found_files) { target_finder.find_files(base_dir, flags) }
let(:found_basenames) { found_files.map { |f| File.basename(f) } }
let(:base_dir) { Dir.pwd }
let(:flags) { 0 }
it 'does not search excluded top level directories' do
config = double('config')
exclude_property = { 'Exclude' => [File.expand_path('dir1/**/*')] }
allow(config).to receive(:for_all_cops).and_return(exclude_property)
allow(config_store).to receive(:for).and_return(config)
expect(found_basenames).not_to include('ruby1.rb')
expect(found_basenames).to include('ruby3.rb')
end
it 'works also if a folder is named ","' do
create_file(',/ruby4.rb', '# encoding: utf-8')
config = double('config')
exclude_property = { 'Exclude' => [File.expand_path('dir1/**/*')] }
allow(config).to receive(:for_all_cops).and_return(exclude_property)
allow(config_store).to receive(:for).and_return(config)
expect(found_basenames).not_to include('ruby1.rb')
expect(found_basenames).to include('ruby3.rb')
expect(found_basenames).to include('ruby4.rb')
end
end
describe '#target_files_in_dir' do
let(:found_files) { target_finder.target_files_in_dir(base_dir) }
let(:found_basenames) { found_files.map { |f| File.basename(f) } }
let(:base_dir) { '.' }
it 'picks files with extension .rb' do
rb_file_count = found_files.count { |f| f.end_with?('.rb') }
expect(rb_file_count).to eq(3)
end
it 'picks ruby executable files with no extension' do
expect(found_basenames).to include('executable')
end
it 'does not pick files with no extension and no ruby shebang' do
expect(found_basenames).not_to include('file')
end
it 'does not pick directories' do
found_basenames = found_files.map { |f| File.basename(f) }
expect(found_basenames).not_to include('dir1')
end
it 'picks files specified to be included in config' do
config = double('config')
allow(config).to receive(:file_to_include?) do |file|
File.basename(file) == 'file'
end
allow(config)
.to receive(:for_all_cops).and_return('Exclude' => [])
allow(config).to receive(:file_to_exclude?).and_return(false)
allow(config_store).to receive(:for).and_return(config)
expect(found_basenames).to include('file')
end
it 'does not pick files specified to be excluded in config' do
config = double('config').as_null_object
allow(config)
.to receive(:for_all_cops).and_return('Exclude' => [])
allow(config).to receive(:file_to_include?).and_return(false)
allow(config).to receive(:file_to_exclude?) do |file|
File.basename(file) == 'ruby2.rb'
end
allow(config_store).to receive(:for).and_return(config)
expect(found_basenames).not_to include('ruby2.rb')
end
context 'when an exception is raised while reading file' do
around do |example|
original_stderr = $stderr
$stderr = StringIO.new
begin
example.run
ensure
$stderr = original_stderr
end
end
before do
allow_any_instance_of(File).to receive(:readline).and_raise(EOFError)
end
context 'and debug mode is enabled' do
let(:debug) { true }
it 'outputs error message' do
found_files
expect($stderr.string).to include('Unprocessable file')
end
end
context 'and debug mode is disabled' do
let(:debug) { false }
it 'outputs nothing' do
found_files
expect($stderr.string).to be_empty
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/rubocop/token_spec.rb 0000664 0000000 0000000 00000001401 13070542236 0022213 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
describe RuboCop::Token do
describe '.from_parser_token' do
subject(:token) { described_class.from_parser_token(parser_token) }
let(:parser_token) { [type, [text, range]] }
let(:type) { :kDEF }
let(:text) { 'def' }
let(:range) { double('range', line: 42, column: 30) }
it "sets parser token's type to rubocop token's type" do
expect(token.type).to eq(type)
end
it "sets parser token's text to rubocop token's text" do
expect(token.text).to eq(text)
end
it "sets parser token's range to rubocop token's pos" do
expect(token.pos).to eq(range)
end
it 'returns a #to_s useful for debugging' do
expect(token.to_s).to eq('[[42, 30], kDEF, "def"]')
end
end
end
rubocop-0.48.1+dfsg.orig/spec/spec_helper.rb 0000664 0000000 0000000 00000002642 13070542236 0020711 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
# Disable colors in specs
require 'rainbow'
Rainbow.enabled = false
# Coverage support needs to be required *before* the RuboCop code is required!
require 'support/coverage'
require 'rubocop'
require 'webmock/rspec'
# Require supporting files exposed for testing.
require 'rubocop/rspec/support'
# Requires supporting files with custom matchers and macros, etc,
# in ./support/ and its subdirectories.
Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
RSpec.configure do |config|
# These two settings work together to allow you to limit a spec run
# to individual examples or groups you care about by tagging them with
# `:focus` metadata. When nothing is tagged with `:focus`, all examples
# get run.
config.filter_run :focus
config.run_all_when_everything_filtered = true
config.example_status_persistence_file_path = 'spec/examples.txt'
config.order = :random
Kernel.srand config.seed
broken_filter = lambda do |v|
v.is_a?(Symbol) ? RUBY_ENGINE == v.to_s : v
end
config.filter_run_excluding broken: broken_filter
config.expect_with :rspec do |expectations|
expectations.include_chain_clauses_in_custom_matcher_descriptions = true
expectations.syntax = :expect # Disable `should`
end
config.mock_with :rspec do |mocks|
mocks.syntax = :expect # Disable `should_receive` and `stub`
mocks.verify_partial_doubles = true
end
end
rubocop-0.48.1+dfsg.orig/spec/support/ 0000775 0000000 0000000 00000000000 13070542236 0017603 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/spec/support/cli_spec_behavior.rb 0000664 0000000 0000000 00000001656 13070542236 0023600 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
RSpec.shared_context 'cli spec behavior' do
include FileHelper
def abs(path)
File.expand_path(path)
end
before do
$stdout = StringIO.new
$stderr = StringIO.new
RuboCop::ConfigLoader.debug = false
# OPTIMIZE: Makes these specs faster. Work directory (the parent of
# .rubocop_cache) is removed afterwards anyway.
RuboCop::ResultCache.inhibit_cleanup = true
end
# Wrap all cli specs in `aggregate_failures` so that the expected and
# actual results of every expectation per example are shown. This is
# helpful because it shows information like expected and actual
# $stdout messages while not using `aggregate_failures` will only
# show information about expected and actual exit code
around do |example|
aggregate_failures(&example)
end
after do
$stdout = STDOUT
$stderr = STDERR
RuboCop::ResultCache.inhibit_cleanup = false
end
end
rubocop-0.48.1+dfsg.orig/spec/support/cops/ 0000775 0000000 0000000 00000000000 13070542236 0020547 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/spec/support/cops/class_must_be_a_module_cop.rb 0000664 0000000 0000000 00000000574 13070542236 0026433 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module RuboCop
module Cop
module Test
class ClassMustBeAModuleCop < RuboCop::Cop::Cop
def on_class(node)
add_offense(node, :expression, 'Class must be a Module')
end
def autocorrect(node)
->(corrector) { corrector.replace(node.loc.keyword, 'module') }
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/support/cops/module_must_be_a_class_cop.rb 0000664 0000000 0000000 00000000574 13070542236 0026433 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module RuboCop
module Cop
module Test
class ModuleMustBeAClassCop < RuboCop::Cop::Cop
def on_module(node)
add_offense(node, :expression, 'Module must be a Class')
end
def autocorrect(node)
->(corrector) { corrector.replace(node.loc.keyword, 'class') }
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/support/coverage.rb 0000664 0000000 0000000 00000000331 13070542236 0021720 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
if ENV['TRAVIS'] || ENV['COVERAGE']
require 'simplecov'
SimpleCov.add_filter '/spec/'
SimpleCov.add_filter '/vendor/bundle/'
SimpleCov.command_name 'rspec'
SimpleCov.start
end
rubocop-0.48.1+dfsg.orig/spec/support/custom_matchers.rb 0000664 0000000 0000000 00000001071 13070542236 0023327 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
RSpec::Matchers.define :exit_with_code do |code|
supports_block_expectations
actual = nil
match do |block|
begin
block.call
rescue SystemExit => e
actual = e.status
end
actual && actual == code
end
failure_message do
"expected block to call exit(#{code}) but exit" +
(actual.nil? ? ' not called' : "(#{actual}) was called")
end
failure_message_when_negated do
"expected block not to call exit(#{code})"
end
description do
"expect block to call exit(#{code})"
end
end
rubocop-0.48.1+dfsg.orig/spec/support/empty_lines_around_body_shared_examples.rb 0000664 0000000 0000000 00000032374 13070542236 0030302 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
shared_examples_for 'empty_lines_around_class_or_module_body' do |type|
context 'when EnforcedStyle is empty_lines_special' do
let(:cop_config) { { 'EnforcedStyle' => 'empty_lines_special' } }
context 'when first child is method' do
it "requires blank line at the beginning and ending of #{type} body" do
inspect_source(cop,
["#{type} SomeObject",
'',
' def do_something; end',
'',
'end'])
expect(cop.messages).to eq([])
end
context 'source without blank lines' do
let(:source) do
["#{type} SomeObject",
' def do_something; end',
'end']
end
it "registers an offense for #{type} not beginning "\
'and ending with a blank line' do
inspect_source(cop, source)
expect(cop.messages).to eq([missing_begin, missing_end])
end
it 'autocorrects the offenses' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(["#{type} SomeObject",
'',
' def do_something; end',
'',
'end'].join("\n"))
end
end
context "when #{type} has a namespace" do
it 'requires no empty lines for namespace but '\
"requires blank line at the beginning and ending of #{type} body" do
inspect_source(cop,
["#{type} Parent",
" #{type} SomeObject",
'',
' def do_something',
' end',
'',
' end',
'end'])
expect(cop.messages).to eq([])
end
context 'source without blank lines' do
let(:source) do
["#{type} Parent",
" #{type} SomeObject",
' def do_something',
' end',
' end',
'end']
end
it 'autocorrects the offenses' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(["#{type} Parent",
" #{type} SomeObject",
'',
' def do_something',
' end',
'',
' end',
'end'].join("\n"))
end
end
context 'source with blank lines' do
let(:source) do
["#{type} Parent",
'',
" #{type} SomeObject",
'',
' def do_something',
' end',
'',
' end',
'',
'end']
end
it 'autocorrects the offenses' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(["#{type} Parent",
" #{type} SomeObject",
'',
' def do_something',
' end',
'',
' end',
'end'].join("\n"))
end
end
end
end
context 'when first child is NOT a method' do
it "does not require blank line at the beginning of #{type} body "\
'but requires blank line before first def definition '\
"and requires blank line at the end of #{type} body" do
inspect_source(cop,
["#{type} SomeObject",
' include Something',
'',
' def do_something; end',
'',
'end'])
expect(cop.messages).to eq([])
end
context 'source without blank lines' do
let(:source) do
["#{type} SomeObject",
' include Something',
' def do_something; end',
'end']
end
it "registers an offense for #{type} not ending with a blank line" do
inspect_source(cop, source)
expect(cop.messages).to eq([missing_def, missing_end])
end
it 'autocorrects the offenses' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(["#{type} SomeObject",
' include Something',
'',
' def do_something; end',
'',
'end'].join("\n"))
end
end
context 'source with blank lines' do
let(:source) do
["#{type} SomeObject",
'',
' include Something',
' def do_something; end',
'',
'end']
end
it "registers an offense for #{type} beginning with a blank line" do
inspect_source(cop, source)
expect(cop.messages).to eq([extra_begin, missing_def])
end
it 'autocorrects the offenses' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(["#{type} SomeObject",
' include Something',
'',
' def do_something; end',
'',
'end'].join("\n"))
end
end
context 'source with comment before method definition' do
let(:source) do
["#{type} SomeObject",
'',
' include Something',
' # Comment',
' def do_something; end',
'',
'end']
end
it "registers an offense for #{type} beginning with a blank line" do
inspect_source(cop, source)
expect(cop.messages).to eq([extra_begin, missing_def])
end
it 'autocorrects the offenses' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(["#{type} SomeObject",
' include Something',
'',
' # Comment',
' def do_something; end',
'',
'end'].join("\n"))
end
end
context "when #{type} has a namespace" do
it 'requires no empty lines for namespace '\
"and does not require blank line at the beginning of #{type} body "\
"but requires blank line at the end of #{type} body" do
inspect_source(cop,
["#{type} Parent",
" #{type} SomeObject",
' include Something',
'',
' def do_something',
' end',
'',
' end',
'end'])
expect(cop.messages).to eq([])
end
context 'source without blank lines' do
let(:source) do
["#{type} Parent",
" #{type} SomeObject",
' include Something',
' def do_something',
' end',
' end',
'end']
end
it 'autocorrects the offenses' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(["#{type} Parent",
" #{type} SomeObject",
' include Something',
'',
' def do_something',
' end',
'',
' end',
'end'].join("\n"))
end
end
context 'source with blank lines' do
let(:source) do
["#{type} Parent",
'',
" #{type} SomeObject",
'',
' include Something',
'',
' def do_something',
' end',
'',
' end',
'',
'end']
end
it 'autocorrects the offenses' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(["#{type} Parent",
" #{type} SomeObject",
' include Something',
'',
' def do_something',
' end',
'',
' end',
'end'].join("\n"))
end
end
context 'source with constants' do
let(:source) do
["#{type} Parent",
" #{type} SomeObject",
' URL = %q(http://example.com)',
' def do_something',
' end',
' end',
'end']
end
it 'autocorrects the offenses' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(["#{type} Parent",
" #{type} SomeObject",
' URL = %q(http://example.com)',
'',
' def do_something',
' end',
'',
' end',
'end'].join("\n"))
end
end
end
end
context 'when namespace has multiple children' do
it 'requires empty lines for namespace' do
inspect_source(cop,
["#{type} Parent",
'',
" #{type} Mom",
'',
' def do_something',
' end',
'',
' end',
" #{type} Dad",
'',
' end',
'',
'end'])
expect(cop.messages).to eq([])
end
end
context "#{type} with only constants" do
let(:source) do
["#{type} Parent",
" #{type} SomeObject",
' URL = %q(http://example.com)',
' WSDL = %q(http://example.com/wsdl)',
' end',
'end']
end
it 'autocorrects the offenses' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(["#{type} Parent",
" #{type} SomeObject",
' URL = %q(http://example.com)',
' WSDL = %q(http://example.com/wsdl)',
'',
' end',
'end'].join("\n"))
end
end
context "#{type} with constant and child #{type}" do
let(:source) do
["#{type} Parent",
' URL = %q(http://example.com)',
" #{type} SomeObject",
' def do_something; end',
' end',
'end']
end
it 'registers offenses' do
inspect_source(cop, source)
expect(cop.messages).to eq([missing_type,
missing_begin,
missing_end,
missing_end])
end
it 'autocorrects the offenses' do
new_source = autocorrect_source(cop, source)
expect(new_source).to eq(["#{type} Parent",
' URL = %q(http://example.com)',
'',
" #{type} SomeObject",
'',
' def do_something; end',
'',
' end',
'',
'end'].join("\n"))
end
end
context "#{type} with empty body" do
context 'with empty line' do
let(:source) do
["#{type} SomeObject",
'',
'end']
end
it 'does NOT register offenses' do
inspect_source(cop, source)
expect(cop.messages).to eq([])
end
end
context 'without empty line' do
let(:source) do
["#{type} SomeObject",
'end']
end
it 'does NOT register offenses' do
inspect_source(cop, source)
expect(cop.messages).to eq([])
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/support/file_helper.rb 0000664 0000000 0000000 00000000667 13070542236 0022417 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'fileutils'
module FileHelper
def create_file(file_path, content)
file_path = File.expand_path(file_path)
dir_path = File.dirname(file_path)
FileUtils.makedirs dir_path unless File.exist?(dir_path)
File.open(file_path, 'w') do |file|
case content
when String
file.puts content
when Array
file.puts content.join("\n")
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/support/jruby_workaround.rb 0000664 0000000 0000000 00000000773 13070542236 0023545 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
# Force JRuby not to select the current working directory
# as a temporary directory on Travis CI.
# https://github.com/jruby/jruby/issues/405
if ENV['TRAVIS'] && RUBY_ENGINE == 'jruby'
require 'fileutils'
tmp_dir = ENV['TMPDIR'] || ENV['TMP'] || ENV['TEMP'] ||
Etc.systmpdir || '/tmp'
non_world_writable_tmp_dir = File.join(tmp_dir, 'rubocop')
FileUtils.makedirs(non_world_writable_tmp_dir, mode: 0o700)
ENV['TMPDIR'] = non_world_writable_tmp_dir
end
rubocop-0.48.1+dfsg.orig/spec/support/mri_syntax_checker.rb 0000664 0000000 0000000 00000004155 13070542236 0024016 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'open3'
# The reincarnation of syntax cop :)
module MRISyntaxChecker
module_function
def offenses_for_source(source, fake_cop_name = 'Syntax', grep_message = nil)
if source.is_a?(Array)
source_lines = source
source = source_lines.join("\n")
else
source_lines = source.each_line.to_a
end
source_buffer = Parser::Source::Buffer.new('test', 1)
source_buffer.source = source
offenses = check_syntax(source).each_line.map do |line|
check_line(line, source_lines, source_buffer, fake_cop_name,
grep_message)
end
offenses.compact
end
def check_line(line, source_lines, source_buffer, fake_cop_name,
grep_message)
line_number, severity, message = process_line(line)
return unless line_number
return if grep_message && !message.include?(grep_message)
begin_pos = source_lines[0...(line_number - 1)].reduce(0) do |a, e|
a + e.length + 1
end
RuboCop::Cop::Offense.new(severity,
Parser::Source::Range.new(source_buffer,
begin_pos,
begin_pos + 1),
message.capitalize,
fake_cop_name)
end
def check_syntax(source)
raise 'Must be running with MRI' unless RUBY_ENGINE == 'ruby'
stdin, stderr, thread = nil
# It's extremely important to run the syntax check in a
# clean environment - otherwise it will be extremely slow.
if defined? Bundler
Bundler.with_clean_env do
stdin, _, stderr, thread = Open3.popen3('ruby', '-cw')
end
else
stdin, _, stderr, thread = Open3.popen3('ruby', '-cw')
end
stdin.write(source)
stdin.close
thread.join
stderr.read
end
def process_line(line)
match_data = line.match(/.+:(\d+): (warning: )?(.+)/)
return nil unless match_data
line_number, warning, message = match_data.captures
severity = warning ? :warning : :error
[line_number.to_i, severity, message]
end
end
rubocop-0.48.1+dfsg.orig/spec/support/multiline_literal_brace_layout_examples.rb 0000664 0000000 0000000 00000025571 13070542236 0030307 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
shared_examples_for 'multiline literal brace layout' do
let(:prefix) { '' } # A prefix before the opening brace.
let(:suffix) { '' } # A suffix for the line after the closing brace.
let(:open) { nil } # The opening brace.
let(:close) { nil } # The closing brace.
let(:a) { 'a' } # The first element.
let(:b) { 'b' } # The second element.
let(:multi_prefix) { '' } # Prefix multi and heredoc with this.
let(:multi) { ['{', 'foo: bar', '}'] } # A viable multi-line element.
# This heredoc is unsafe to edit around because it ends on the same line as
# the node itself.
let(:heredoc) { ['<<-EOM', 'baz', 'EOM'] }
# This heredoc is safe to edit around because it ends on a line before the
# last line of the node.
let(:safe_heredoc) { ['{', 'a: <<-EOM', 'baz', 'EOM', '}'] }
def make_multi(multi)
multi = multi.dup
multi[0] = multi_prefix + multi[0]
multi
end
# Construct the source code for the braces. For instance, for an array
# the `open` brace would be `[` and the `close` brace would be `]`, so
# you could construct the following:
#
# braces(true, 'a', 'b', 'c', false)
#
# [ # line break indicated by `true` as the first argument.
# a,
# b,
# c] # no line break indicated by `false` as the last argument.
#
# This method also supports multi-line arguments. For example:
#
# braces(true, 'a', ['{', 'foo: bar', '}'], true)
#
# [ # line break indicated by `true` as the first argument.
# a,
# {
# foo: bar
# } # line break indicated by `true` as the last argument.
# ]
def braces(open_line_break, *args, close_line_break)
args = [a, b] if args.empty?
open + (open_line_break ? "\n" : '') +
args.map { |a| a.respond_to?(:join) ? a.join("\n") : a }.join(",\n") +
(close_line_break ? "\n" : '') + close
end
# Construct a piece of source code for brace layout testing. This farms
# out most of the work to `#braces` but it also includes a prefix and suffix.
def construct(*args)
(prefix + braces(*args) + "\n" + suffix).split("\n")
end
context 'heredoc' do
let(:cop_config) { { 'EnforcedStyle' => 'same_line' } }
it 'ignores heredocs that could share a last line' do
inspect_source(cop, construct(false, a, make_multi(heredoc), true))
expect(cop.offenses).to be_empty
end
it 'detects heredoc structures that are safe to add to' do
inspect_source(cop, construct(false, a, make_multi(safe_heredoc), true))
expect(cop.offenses.size).to eq(1)
end
it 'auto-corrects safe heredoc offenses' do
new_source = autocorrect_source(
cop, construct(false, a, make_multi(safe_heredoc), true)
)
expect(new_source)
.to eq(construct(false, a, make_multi(safe_heredoc), false).join("\n"))
end
end
context 'symmetrical style' do
let(:cop_config) { { 'EnforcedStyle' => 'symmetrical' } }
context 'opening brace on same line as first element' do
it 'allows closing brace on same line as last element' do
inspect_source(cop, construct(false, false))
expect(cop.offenses).to be_empty
end
it 'allows closing brace on same line as last multiline element' do
inspect_source(cop, construct(false, a, make_multi(multi), false))
expect(cop.offenses).to be_empty
end
it 'detects closing brace on different line from last element' do
src = construct(false, true)
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line)
.to eq(src.length - (suffix.empty? ? 0 : 1))
expect(cop.highlights).to eq([close])
expect(cop.messages).to eq([described_class::SAME_LINE_MESSAGE])
end
it 'autocorrects closing brace on different line from last element' do
new_source = autocorrect_source(cop, ["#{prefix}#{open}#{a}, # a",
"#{b} # b",
close,
suffix])
expect(new_source)
.to eq("#{prefix}#{open}#{a}, # a\n#{b}#{close} # b\n#{suffix}")
end
end
context 'opening brace on separate line from first element' do
it 'allows closing brace on separate line from last element' do
inspect_source(cop, construct(true, true))
expect(cop.offenses).to be_empty
end
it 'allows closing brace on separate line from last multiline element' do
inspect_source(cop, construct(true, a, make_multi(multi), true))
expect(cop.offenses).to be_empty
end
it 'detects closing brace on same line as last element' do
src = construct(true, false)
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line)
.to eq(src.length - (suffix.empty? ? 0 : 1))
expect(cop.highlights).to eq([close])
expect(cop.messages).to eq([described_class::NEW_LINE_MESSAGE])
end
it 'autocorrects closing brace on same line from last element' do
new_source = autocorrect_source(cop, construct(true, false))
expect(new_source).to eq(construct(true, true).join("\n"))
end
end
end
context 'new_line style' do
let(:cop_config) { { 'EnforcedStyle' => 'new_line' } }
context 'opening brace on same line as first element' do
it 'allows closing brace on different line from last element' do
inspect_source(cop, construct(false, true))
expect(cop.offenses).to be_empty
end
it 'allows closing brace on different line from multi-line element' do
inspect_source(cop, construct(false, a, make_multi(multi), true))
expect(cop.offenses).to be_empty
end
it 'detects closing brace on same line as last element' do
src = construct(false, false)
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line)
.to eq(src.length - (suffix.empty? ? 0 : 1))
expect(cop.highlights).to eq([close])
expect(cop.messages).to eq([described_class::ALWAYS_NEW_LINE_MESSAGE])
end
it 'detects closing brace on same line as last multiline element' do
src = construct(false, a, make_multi(multi), false)
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line)
.to eq(src.length - (suffix.empty? ? 0 : 1))
expect(cop.highlights).to eq([close])
expect(cop.messages).to eq([described_class::ALWAYS_NEW_LINE_MESSAGE])
end
it 'autocorrects closing brace on same line as last element' do
new_source = autocorrect_source(cop, ["#{prefix}#{open}#{a}, # a",
"#{b}#{close} # b",
suffix])
expect(new_source)
.to eq("#{prefix}#{open}#{a}, # a\n#{b}\n#{close} # b\n#{suffix}")
end
end
context 'opening brace on separate line from first element' do
it 'allows closing brace on separate line from last element' do
inspect_source(cop, construct(true, true))
expect(cop.offenses).to be_empty
end
it 'allows closing brace on separate line from last multiline element' do
inspect_source(cop, construct(true, a, make_multi(multi), true))
expect(cop.offenses).to be_empty
end
it 'detects closing brace on same line as last element' do
src = construct(true, false)
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line)
.to eq(src.length - (suffix.empty? ? 0 : 1))
expect(cop.highlights).to eq([close])
expect(cop.messages).to eq([described_class::ALWAYS_NEW_LINE_MESSAGE])
end
it 'autocorrects closing brace on same line from last element' do
new_source = autocorrect_source(cop, construct(true, false))
expect(new_source).to eq(construct(true, true).join("\n"))
end
end
end
context 'same_line style' do
let(:cop_config) { { 'EnforcedStyle' => 'same_line' } }
context 'opening brace on same line as first element' do
it 'allows closing brace on same line from last element' do
inspect_source(cop, construct(false, false))
expect(cop.offenses).to be_empty
end
it 'allows closing brace on same line as multi-line element' do
inspect_source(cop, construct(false, a, make_multi(multi), false))
expect(cop.offenses).to be_empty
end
it 'detects closing brace on different line from last element' do
src = construct(false, true)
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line)
.to eq(src.length - (suffix.empty? ? 0 : 1))
expect(cop.highlights).to eq([close])
expect(cop.messages).to eq([described_class::ALWAYS_SAME_LINE_MESSAGE])
end
it 'detects closing brace on different line from multiline element' do
src = construct(false, a, make_multi(multi), true)
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line)
.to eq(src.length - (suffix.empty? ? 0 : 1))
expect(cop.highlights).to eq([close])
expect(cop.messages).to eq([described_class::ALWAYS_SAME_LINE_MESSAGE])
end
it 'autocorrects closing brace on different line as last element' do
new_source = autocorrect_source(cop, ["#{prefix}#{open}#{a}, # a",
"#{b} # b",
close,
suffix])
expect(new_source)
.to eq("#{prefix}#{open}#{a}, # a\n#{b}#{close} # b\n#{suffix}")
end
end
context 'opening brace on separate line from first element' do
it 'allows closing brace on same line as last element' do
inspect_source(cop, construct(true, false))
expect(cop.offenses).to be_empty
end
it 'allows closing brace on same line as last multiline element' do
inspect_source(cop, construct(true, a, make_multi(multi), false))
expect(cop.offenses).to be_empty
end
it 'detects closing brace on different line from last element' do
src = construct(true, true)
inspect_source(cop, src)
expect(cop.offenses.size).to eq(1)
expect(cop.offenses.first.line)
.to eq(src.length - (suffix.empty? ? 0 : 1))
expect(cop.highlights).to eq([close])
expect(cop.messages).to eq([described_class::ALWAYS_SAME_LINE_MESSAGE])
end
it 'autocorrects closing brace on different line from last element' do
new_source = autocorrect_source(cop, construct(true, true))
expect(new_source).to eq(construct(true, false).join("\n"))
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/support/multiline_literal_brace_layout_trailing_comma_examples.rb 0000664 0000000 0000000 00000003342 13070542236 0033344 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
shared_examples_for 'multiline literal brace layout trailing comma' do
let(:prefix) { '' } # A prefix before the opening brace.
let(:suffix) { '' } # A suffix for the line after the closing brace.
let(:open) { nil } # The opening brace.
let(:close) { nil } # The closing brace.
let(:a) { 'a' } # The first element.
let(:b) { 'b' } # The second element.
context 'symmetrical style' do
let(:cop_config) { { 'EnforcedStyle' => 'symmetrical' } }
context 'opening brace on same line as first element' do
context 'last element has a trailing comma' do
it 'autocorrects closing brace on different line from last element' do
new_source = autocorrect_source(cop, ["#{prefix}#{open}#{a}, # a",
"#{b}, # b",
close,
suffix])
expect(new_source)
.to eq("#{prefix}#{open}#{a}, # a\n#{b},#{close} # b\n#{suffix}")
end
end
end
end
context 'same_line style' do
let(:cop_config) { { 'EnforcedStyle' => 'same_line' } }
context 'opening brace on same line as first element' do
context 'last element has a trailing comma' do
it 'autocorrects closing brace on different line as last element' do
new_source = autocorrect_source(cop, ["#{prefix}#{open}#{a}, # a",
"#{b}, # b",
close,
suffix])
expect(new_source)
.to eq("#{prefix}#{open}#{a}, # a\n#{b},#{close} # b\n#{suffix}")
end
end
end
end
end
rubocop-0.48.1+dfsg.orig/spec/support/statement_modifier_helper.rb 0000664 0000000 0000000 00000002745 13070542236 0025361 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module StatementModifierHelper
def check_empty(cop, keyword)
inspect_source(cop, ["#{keyword} cond",
'end'])
expect(cop.offenses).to be_empty
end
def check_really_short(cop, keyword)
inspect_source(cop, ["#{keyword} a",
' b',
'end'])
expect(cop.messages).to eq(
["Favor modifier `#{keyword}` usage when having a single-line body."]
)
expect(cop.offenses.map { |o| o.location.source }).to eq([keyword])
end
def autocorrect_really_short(cop, keyword)
corrected = autocorrect_source(cop,
["#{keyword} a",
' b',
'end'])
expect(corrected).to eq "b #{keyword} a"
end
def check_too_long(cop, keyword)
# This statement is one character too long to fit.
condition = 'a' * (40 - keyword.length)
body = 'b' * 37
expect(" #{body} #{keyword} #{condition}".length).to eq(81)
inspect_source(cop,
[" #{keyword} #{condition}",
" #{body}",
' end'])
expect(cop.offenses).to be_empty
end
def check_short_multiline(cop, keyword)
inspect_source(cop,
["#{keyword} ENV['COVERAGE']",
" require 'simplecov'",
' SimpleCov.start',
'end'])
expect(cop.messages).to be_empty
end
end
rubocop-0.48.1+dfsg.orig/tasks/ 0000775 0000000 0000000 00000000000 13070542236 0016262 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/tasks/cops_documentation.rake 0000664 0000000 0000000 00000011727 13070542236 0023033 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'yard'
require 'rubocop'
desc 'Generate docs of all cops departments'
task generate_cops_documentation: :yard do
def cops_of_department(cops, department)
cops.with_department(department).sort!
end
def cops_body(config, cop, description, examples_objects, pars)
content = h2(cop.cop_name)
content << properties(config, cop)
content << "\n\n"
content << "#{description}\n"
content << examples(examples_objects) if examples_objects.count > 0
content << default_settings(pars)
content << references(config, cop)
content
end
def examples(examples_object)
content = h3('Example')
content += examples_object.map { |e| code_example(e) }.join
content
end
def properties(config, cop)
content = "Enabled by default | Supports autocorrection\n".dup
content << "--- | ---\n"
enabled_by_default = config.for_cop(cop).fetch('Enabled')
default_status = enabled_by_default ? 'Enabled' : 'Disabled'
supports_autocorrect = cop.new.support_autocorrect? ? 'Yes' : 'No'
content << "#{default_status} | #{supports_autocorrect}"
content
end
def h2(title)
content = "\n".dup
content << "## #{title}\n"
content << "\n"
content
end
def h3(title)
content = "\n".dup
content << "### #{title}\n"
content << "\n"
content
end
def code_example(ruby_code)
content = "```ruby\n".dup
content << ruby_code.text.gsub('@good', '# good')
.gsub('@bad', '# bad').strip
content << "\n```\n"
content
end
def default_settings(pars)
return '' unless pars.keys.count > 0
content = h3('Important attributes')
content << "Attribute | Value\n"
content << "--- | ---\n"
pars.each do |par|
content << "#{par.first} |#{format_table_value(par.last)}\n"
end
content
end
def format_table_value(v)
value = v.is_a?(Array) ? v.join(', ') : v.to_s
value = value.gsub("#{Dir.pwd}/", '').gsub('*', '\*')
" #{value}".rstrip
end
def references(config, cop)
cop_config = config.for_cop(cop)
urls = RuboCop::Cop::MessageAnnotator.new(config, cop_config, {}).urls
return '' if urls.empty?
content = h3('References')
content << urls.map { |url| "* [#{url}](#{url})" }.join("\n")
content << "\n"
content
end
def print_cops_of_department(cops, department, config)
selected_cops = cops_of_department(cops, department)
content = "# #{department}\n".dup
selected_cops.each do |cop|
content << print_cop_with_doc(cop, config)
end
file_name = "#{Dir.pwd}/manual/cops_#{department.downcase}.md"
file = File.open(file_name, 'w')
puts "* generated #{file_name}"
file.write(content.strip + "\n")
end
def print_cop_with_doc(cop, config)
t = config.for_cop(cop)
non_display_keys = %w[Description Enabled StyleGuide Reference]
pars = t.reject { |k| non_display_keys.include? k }
description = 'No documentation'
examples_object = []
YARD::Registry.all(:class).detect do |code_object|
next unless RuboCop::Cop::Badge.for(code_object.to_s) == cop.badge
description = code_object.docstring unless code_object.docstring.blank?
examples_object = code_object.tags('example')
end
cops_body(config, cop, description, examples_object, pars)
end
def table_of_content_for_department(cops, department)
type_title = department[0].upcase + department[1..-1]
filename = "cops_#{department.downcase}.md"
content = "#### Department [#{type_title}](#{filename})\n\n".dup
cops_of_department(cops, department.to_sym).each do |cop|
anchor = cop.cop_name.sub('/', '').downcase
content << "* [#{cop.cop_name}](#{filename}##{anchor})\n"
end
content
end
def print_table_of_contents(cops)
path = "#{Dir.pwd}/manual/cops.md"
original = File.read(path)
content = "\n".dup
content << table_contents(cops)
content << "\n"
content = original.sub(
/.+/m, content
)
File.write(path, content)
end
def table_contents(cops)
cops
.departments
.map(&:to_s)
.sort
.map { |department| table_of_content_for_department(cops, department) }
.join("\n")
end
def assert_manual_synchronized
# Do not print diff and yield whether exit code was zero
sh('git diff --quiet manual') do |outcome, _|
return if outcome
# Output diff before raising error
sh('git diff manual')
raise 'The manual directory is out of sync. ' \
'Run rake generate_cops_documentation and commit the results.'
end
end
cops = RuboCop::Cop::Cop.registry
config = RuboCop::ConfigLoader.default_configuration
config['Rails']['Enabled'] = true
YARD::Registry.load!
cops.departments.sort!.each do |department|
print_cops_of_department(cops, department, config)
end
print_table_of_contents(cops)
assert_manual_synchronized if ENV['CI'] == 'true'
end
rubocop-0.48.1+dfsg.orig/tasks/new_cop.rake 0000664 0000000 0000000 00000006167 13070542236 0020572 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'rubocop'
desc 'Generate a new cop template'
task :new_cop, [:cop] do |_task, args|
def to_snake(str)
str
.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
.gsub(/([a-z\d])([A-Z])/, '\1_\2')
.tr('-', '_')
.downcase
end
cop_name = args[:cop] # Department/Name
raise ArgumentError, 'One argument is required' unless cop_name
badge = RuboCop::Cop::Badge.parse(cop_name)
unless badge.qualified?
raise ArgumentError, 'Specify a cop name with Department/Name style'
end
cop_code = <<-END.strip_indent
# frozen_string_literal: true
# TODO: when finished, run `rake generate_cops_documentation` to update the docs
module RuboCop
module Cop
module #{badge.department}
# TODO: Write cop description and example of bad / good code.
#
# @example
# # bad
# bad_method()
#
# # bad
# bad_method(args)
#
# # good
# good_method()
#
# # good
# good_method(args)
class #{badge.cop_name} < Cop
# TODO: Implement the cop into here.
#
# In many cases, you can use a node matcher for matching node pattern.
# See. https://github.com/bbatsov/rubocop/blob/master/lib/rubocop/node_pattern.rb
#
# For example
MSG = 'Message of #{badge.cop_name}'.freeze
def_node_matcher :bad_method?, <<-PATTERN
(send nil :bad_method ...)
PATTERN
def on_send(node)
return unless bad_method?(node)
add_offense(node, :expression)
end
end
end
end
end
END
cop_path = "lib/rubocop/cop/#{to_snake(badge.to_s)}.rb"
raise "#{cop_path} already exists!" if File.exist?(cop_path)
File.write(cop_path, cop_code)
spec_code = <<-END.strip_indent
# frozen_string_literal: true
describe RuboCop::Cop::#{badge.department}::#{badge.cop_name} do
let(:config) { RuboCop::Config.new }
subject(:cop) { described_class.new(config) }
# TODO: Write test code
#
# For example
it 'registers an offense for offending code' do
inspect_source(cop, 'bad_method')
expect(cop.offenses.size).to eq(1)
expect(cop.messages)
.to eq(['Message of #{badge.cop_name}'])
end
it 'accepts' do
inspect_source(cop, 'good_method')
expect(cop.offenses).to be_empty
end
end
END
spec_path = "spec/rubocop/cop/#{to_snake(cop_name)}_spec.rb"
raise "#{spec_path} already exists!" if File.exist?(spec_path)
File.write(spec_path, spec_code)
puts <<-END.strip_indent
created
- #{cop_path}
- #{spec_path}
Do 4 steps
- Add an entry to `New feature` section in CHANGELOG.md
- e.g. Add new `#{badge.cop_name}` cop. ([@your_id][])
- Add `require '#{cop_path.gsub(/\.rb$/, '').gsub(%r{^lib/}, '')}'` into lib/rubocop.rb
- Add an entry into config/enabled.yml or config/disabled.yml
- Implement a new cop to the generated file!
END
end
### Open Collective Sponsors
Become a sponsor and get your logo on our README on Github with a link to your site. [[Become a sponsor](https://opencollective.com/rubocop#sponsor)]
## Changelog
RuboCop's changelog is available [here](CHANGELOG.md).
## Copyright
Copyright (c) 2012-2017 Bozhidar Batsov. See [LICENSE.txt](LICENSE.txt) for
further details.
rubocop-0.48.1+dfsg.orig/Rakefile 0000664 0000000 0000000 00000004467 13070542236 0016615 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'rubygems'
require 'bundler'
require 'bundler/gem_tasks'
begin
Bundler.setup(:default, :development)
rescue Bundler::BundlerError => e
$stderr.puts e.message
$stderr.puts 'Run `bundle install` to install missing gems'
exit e.status_code
end
require 'rake'
require 'rspec/core'
require 'rspec/core/rake_task'
require 'rubocop/rake_task'
Dir['tasks/**/*.rake'].each { |t| load t }
RSpec::Core::RakeTask.new(:spec)
RSpec::Core::RakeTask.new(:ascii_spec) { |t| t.ruby_opts = '-E ASCII' }
desc 'Run RSpec with code coverage'
task :coverage do
ENV['COVERAGE'] = 'true'
Rake::Task['spec'].execute
end
desc 'Run RuboCop over itself'
RuboCop::RakeTask.new(:internal_investigation)
task default: %i[spec ascii_spec internal_investigation]
require 'yard'
YARD::Rake::YardocTask.new
desc 'Open a REPL for experimentation'
task :repl do
require 'pry'
require 'rubocop'
ARGV.clear
RuboCop.pry
end
desc 'Benchmark a cop on given source file/dir'
task :bench_cop, %i[cop srcpath times] do |_task, args|
require 'benchmark'
require 'rubocop'
include RuboCop
include RuboCop::Formatter::TextUtil
cop_name = args[:cop]
src_path = args[:srcpath]
iterations = args[:times] ? args[:times].to_i : 1
cop_class = if cop_name.include?('/')
Cop::Cop.all.find { |klass| klass.cop_name == cop_name }
else
Cop::Cop.all.find do |klass|
klass.cop_name[/[a-zA-Z]+$/] == cop_name
end
end
raise "No such cop: #{cop_name}" if cop_class.nil?
config = ConfigLoader.load_file(ConfigLoader::DEFAULT_FILE)
cop = cop_class.new(config)
puts "Benchmarking #{cop.cop_name} on #{src_path} (using default config)"
files = if File.directory?(src_path)
Dir[File.join(src_path, '**', '*.rb')]
else
[src_path]
end
puts "(#{pluralize(iterations, 'iteration')}, " \
"#{pluralize(files.size, 'file')})"
ruby_version = RuboCop::Config::KNOWN_RUBIES.last
srcs = files.map { |file| ProcessedSource.from_file(file, ruby_version) }
puts 'Finished parsing source, testing inspection...'
puts(Benchmark.measure do
iterations.times do
commissioner = Cop::Commissioner.new([cop], [])
srcs.each { |src| commissioner.investigate(src) }
end
end)
end
rubocop-0.48.1+dfsg.orig/assets/ 0000775 0000000 0000000 00000000000 13070542236 0016437 5 ustar 00root root 0000000 0000000 rubocop-0.48.1+dfsg.orig/assets/output.html.erb 0000664 0000000 0000000 00000015702 13070542236 0021441 0 ustar 00root root 0000000 0000000
