relnotes/CHANGELOG_v0.md
See current entries: https://github.com/rubocop/rubocop/blob/master/CHANGELOG.md
Style/TernaryParentheses with defined?. (@dvandersluis)Lint/RedundantSafeNavigation to be more safe. (@fatkodima)Style/RedundantBegin with a postfix while or until. (@dvandersluis)Style/RedundantBegin when using begin for or assignment and method call. (@koic)Lint/AmbiguousRegexpLiteral when using regexp without method calls in nested structure. (@koic)Metrics/ClassLength when multiple assignments to constants. (@koic)Style/RedundantBegin when using begin for method argument or part of conditions. (@koic)Style/ClassEqualityComparison when comparing class name. (@koic)Style/ClassLength when overlapping constant assignments. (@koic)Lint/HashCompareByIdentity cop. (@fatkodima)Style/ClassEqualityComparison cop. (@fatkodima)Lint/RedundantSafeNavigation cop. (@fatkodima)Style/RedundantBegin aware of begin without rescue or ensure. (@koic)Lint/NoReturnInBeginEndBlocks cop. (@jcfausto)Style/RaiseArgs. (@pbernays)Lint/BooleanSymbol when used within %i[...]. (@fatkodima)Style/For. (@pbernays)Layout/SpaceAroundEqualsInParameterDefault only registered once in a line. (@rdunlop)Style/MethodDefParentheses per file. (@rdunlop)Style/ExplicitBlockArgument when code is called outside of a method. (@ghiculescu)Style/CaseLikeIf cop. (@dsavochkin)Style/NestedTernaryOperator when using a nested ternary operator expression with no parentheses on the outside. (@koic)Style/ParenthesesAsGroupedExpression when method argument parentheses are omitted and hash argument key is enclosed in parentheses. (@koic)Style/StringConcatenation when string includes double quotes. (@tleish)Style/RedundantCondition when using assignment by hash key access. (@koic)Style/CombinableLoops when using the same method with different arguments. (@dvandersluis)Lint/AmbiguousRegexpLiteral when sending method to regexp literal receiver. (@koic)Style/RedundantInterpolation when using string interpolation for non-operator methods. (@koic)Lint/AmbiguousBlockAssociation cop. (@AllanSiqueira)Layout/EmptyLinesAroundAccessModifier and Style/AccessModifierDeclarations when using only access modifier. (@koic)RegexpNode#parsed_tree now processes regexps including interpolation (by blanking the interpolation before parsing, rather than skipping). (@owst)Style/RedundantRegexpCharacterClass and Style/RedundantRegexpEscape by using regexp_parser gem. (@owst)TargetFinder class which improves initial startup speed. (@tleish)Struct.new. (@tejasbubane)Gemspec/RequiredRubyVersion cop aware of Gem::Requirement. (@tejasbubane)--regenerate-todo. (@dvandersluis)AllowedMethods option to Style/OptionalBooleanParameter cop. (@fatkodima)Style/DateTime. (@dvandersluis)Layout/ArrayAlignment with parallel assignment. (@dvandersluis)TargetFinder class which improves rubocop initial startup speed. (@tleish)Style/ArrayCoercion cop by default. (@koic)Lint/IdentityComparison when calling object_id method without receiver in LHS or RHS. (@koic)Style/RedundantReturn when a rescue has an else clause. (@fatkodima)Layout/RescueEnsureAlignment when Layout/BeginEndAlignment cop is not enabled status. (@koic)Naming/VariableNumber when naming multibyte character variable name. (@koic)Lint/UselessTimes when there is a blank line in the method definition. (@koic)Style/HashAsLastArrayItem when the hash is in an implicit array. (@dvandersluis)Lint/UselessTimes when using empty block argument. (@koic)Metrics/AbcSize. (@marcandre)Style/MultilineWhenThen when line break for multiple candidate values of when statement. (@koic)Style/RandomWithOffset when using a range with non-integer bounds. (@eugeneius)Layout/EmptyLinesAroundAccessModifier with Layout/EmptyLinesAroundBlockBody when using access modifier with block argument. (@koic)Lint/RedundantCopEnableDirective autocorrection to not leave orphaned empty # rubocop:enable comments. (@dvandersluis)Lint/RedundantCopDisableDirective autocorrection. (@dvandersluis)Layout/CaseIndentation not showing the cop name in output messages. (@dvandersluis)Style/OneLineConditional when using if-then-elsif-then-end. (@koic)Style/IfUnlessModifier to ignore cop disable comment directives when considering conversion to the modifier form. (@dsavochkin)respond_to_missing? from OptionalBooleanParameter cop. (@em-gazelle)Style/SafeNavigation marked as having unsafe auto-correction. (@marcandre)Style/IpAddresses by default in Gemfile and gemspec files. (@dvandersluis)--cache-root and support for the RUBOCOP_CACHE_ROOT environment variable. Both can be used to override the AllCops: CacheRootDirectory config, especially in a CI setting. (@sascha-wolf)Layout/BeginEndAlignment cop. (@koic)Lint/IdentityComparison cop. (@koic)Lint/UselessTimes cop. (@dvandersluis)Lint/ConstantDefinitionInBlock cop. (@eugeneius)Lint/DuplicateRequire when same feature argument but different require method. (@koic)Layout/EmptyLineAfterMultilineCondition when conditional is at the top level. (@fatkodima)Style/RedundantSelfAssignment when calling coercion methods. (@fatkodima)Lint/EmptyFile. (@fatkodima)Lint/UnreachableLoop when conditional branch includes continue statement preceding break statement. (@fatkodima)Style/RedundantParentheses when parentheses are used like method argument parentheses. (@koic)Style/HashTransformKeys and Style/HashTransformValues when the receiver is an array. (@eugeneius)Layout/DefEndAlignment when using refinements and private def. (@koic)Style/ClassAndModuleChildren when using cbase class name. (@koic)Style/SafeNavigation when checking foo&.empty? in a conditional. (@koic)Style/ClassAndModuleChildren when using cbase module name. (@koic)Naming/BinaryOperatorParameterName when naming multibyte character method name. (@koic)Bundler/DuplicatedGem when gem is duplicated in condition. (@tejasbubane)Style/ExplicitBlockArgument when using safe navigation method call. (@koic)Style/HashAsLastArrayItem with no_braces for empty hash. (@fsateler)Style/HashTransformKeys and Style/HashTransformValues when the each_with_object hash is used in the transformed key or value. (@eugeneius)Style/GlobalStdStream as unsafe autocorrection. (@marcandre)Style/SpaceInsideHashLiteralBraces when a correct empty hash precedes the incorrect hash. (@dvandersluis)Lint/UselessMethodDefinition. (@marcandre)Lint/AmbiguousOperator when using safe navigation operator with a unary operator. (@koic)Style/MultilineTernaryOperator when returning a multiline ternary operator expression. (@koic)Style/CaseEquality cop when the receiver is not a camel cased constant. (@koic)--format=json and --stdin options. (@koic)Style/StringConcatenation when parts of the expression are too complex. (@dvandersluis)Lint/UselessMethodDefinition to not register an offense when method definition includes optional arguments. (@fatkodima)Style/HashAsLastArrayItem to not register an offense when all items in an array are hashes. (@dvandersluis)in? to AllowedMethods for Lint/SafeNavigationChain cop. (@tejasbubane)mtime, which changes each CI build. (@dvandersluis)Style/ClassMethodsDefinitions. (@dvandersluis)Style/RedundantSelfAssignment cop. (@fatkodima)Layout/EmptyLineAfterMultilineCondition cop. (@fatkodima)Style/SoleNestedConditional cop. (@fatkodima)Style/KeywordParametersOrder cop. (@fatkodima)Style/CombinableLoops cop. (@fatkodima)Style/ClassMethodsDefinitions cop. (@fatkodima)Lint/DuplicateRequire cop. (@fatkodima)Lint/UselessMethodDefinition cop. (@fatkodima)Lint/EmptyFile cop. (@fatkodima)Lint/TrailingCommaInAttributeDeclaration cop. (@drenmi):restore_registry context and stub_cop_class helper class. (@marcandre)Cop.documentation_url. (@marcandre)RegexpNode#each_capture and parsed_tree. (@marcandre)on_send can be optimized by defining the constant RESTRICT_ON_SEND with a list of acceptable method names. (@marcandre)Style/CaseLikeIf when conditional contains comparison with a class. Mark Style/CaseLikeIf as not safe. (@fatkodima)Layout/EmptyLineBetweenDefs. (@fatkodima)Lint/BinaryOperatorWithIdenticalOperands for binary operators used as unary operators. (@marcandre)Bundler/GemComment. (@pocke)Style/RescueModifier to handle parentheses around rescue modifiers. (@dsavochkin)Style/CaseEquality cop when comparing with === against a regular expression receiver. (@koic)Layout/EmptyLinesAroundClassBody and Layout/EmptyLinesAroundModuleBody to correctly handle an access modifier as a first child. (@dsavochkin)Lint/ConstantResolution cop reporting offense for module and class definitions. (@tejasbubane)Style/MultilineWhenThen cop to correctly handle cases with multiline body. (@dsavochkin)Style/OneLineConditional cop to handle if/then/elsif/then/else/end cases. Add AlwaysCorrectToMultiline config option to this cop to always convert offenses to the multi-line form (false by default). (@Lykos, @dsavochkin)Layout/{Def}EndAlignment, Lint/EmptyEnsure, Style/ClassAndModuleChildren. (@marcandre)Style/RedundantRegexpEscape false positive for line continuations. (@owst)Style/RedundantRegexpCharacterClass false positive for interpolated multi-line expressions. (@owst)Style/CaseLikeIf cop where it does not properly handle overridden equality methods with no arguments. (@Skipants).rubocop.yml as well as a notice about NewCops: enable config option. (@colszowka)Lint/ShadowingOuterLocalVariable documentation. (@chocolateboy)Style/HashTransformKeys and Style/HashTransformValues aware of to_h with block. (@eugeneius)Style/FrozenStringLiteralComment as Safe, but with unsafe auto-correction. (@marcandre)to_enum(:scan, regexp) to work on TruffleRuby. (@jaimerave)Lint/OutOfRangeRegexpRef when a regexp is defined and matched in separate steps. (@eugeneius)when, grep, gsub, gsub!, sub, sub!, [], slice, slice!, scan, index, rindex, partition, rpartition, start_with?, and end_with? in Lint/OutOfRangeRegexpRef. (@eugeneius)Lint/UriRegexp when using regexp method without receiver. (@koic)Lint/BinaryOperatorWithIdenticalOperands for mathematical operations. (@marcandre)Lint/MissingSuper. (@marcandre)Style/SymbolArray and Style/WordArray. (@biinari)Style/HashAsLastArrayItem when there are duplicate hashes in the array. (@wcmonty)Style/IfUnlessModifier to add parentheses when converting if-end condition inside a parenthesized method argument list. (@dsavochkin)Style/CaseEquality cop. (@fatkodima)Gemspec/RequiredRubyVersion cop with check that required_ruby_version is specified. (@fatkodima)Lint/SelfAssignment cop. (@fatkodima)Lint/DuplicateRescueException cop. (@fatkodima)Lint/BinaryOperatorWithIdenticalOperands cop. (@fatkodima)Lint/UnreachableLoop cop. (@fatkodima)Style/OptionalBooleanParameter cop. (@fatkodima)Lint/FloatComparison cop. (@fatkodima)Lint/MissingSuper cop. (@fatkodima)Style/ExplicitBlockArgument cop. (@fatkodima)Lint/Loop cop. (@fatkodima)Config#for_badge as an efficient way to get a cop's config merged with its department's. (@marcandre)Style/StringConcatenation cop. (@fatkodima)Lint/TopLevelReturnWithArgument cop. (@iamravitejag)Style/GlobalStdStream cop. (@fatkodima)Style/SingleArgumentDig cop. (@volfgox)Lint/EmptyConditionalBody cop. (@fatkodima)Lint/OutOfRangeRegexpRef cop. (@sonalinavlakhe)Style/MethodCallWithArgsParentheses EnforcedStyle: omit_parentheses to fix invalid Ruby auto-correction. (@gsamokovarov)Layout/SpaceAroundMethodCallOperator when using Proc#call shorthand syntax. (@fatkodima)Style/ConditionalAssignment to preserve constant namespace. (@biinari)Style/CaseLikeIf when checking against equal? and match? without a receiver. (@fatkodima)Style/HashAsLastArrayItem when hash is not a last array item. (@fatkodima)Style/RedundantCondition when using raise, rescue, or and without argument parentheses in else. (@koic)Style/RedundantRegexpEscape. (@owst)EnforcedStyle: hash_rockets of Style/HashSyntax with Layout/HashAlignment. (@koic)Style/EmptyMethod. (@koic)Lint/EnsureReturn. (@marcandre)Style/ArrayCoercion as not safe. (@marcandre)Style/AccessorGrouping's auto-correction to remove redundant blank lines. (@koic)Style/MissingRespondToMissing when defined method with inline access modifier. (@koic)Lint/SelfAssignment when using or-assignment for constant. (@koic)Style/SingleArgumentDig when without a receiver. (@koic)Lint/IneffectiveAccessModifier when there is begin...end before a method definition. (@koic)Style/IfUnlessModifier to correctly take into account code before the if condition when considering conversation to a single-line form. (@dsavochkin)Style/IfUnlessModifier to correctly take into account a comment on the first line when considering conversation to a single-line form. (@dsavochkin)Style/IfUnlessModifier to correctly take into account code on the last line after the end keyword when considering conversion to a single-line form. (@dsavochkin)Style/IfUnlessModifier to add parentheses when converting if-end condition inside an array or a hash to a single-line form. (@dsavochkin)Style/StructInheritance when there is a comment before class declaration. (@koic)Layout/FirstMethodArgumentLineBreak when using kwargs in super. (@koic)Style/NestedParenthesizedCalls to include line continuations in whitespace for auto-correct. (@biinari)Style/MethodMissingSuper cop is removed in favor of new Lint/MissingSuper cop. (@fatkodima)Lint/UselessComparison cop is removed in favor of new Lint/BinaryOperatorWithIdenticalOperands cop. (@fatkodima)Style/MultilineMethodSignature. (@koic)Metrics/AbcSize now counts ||=, &&=, multiple assignments, for, yield, iterating blocks. &. now count as conditions too (unless repeated on the same variable). Default bumped from 15 to 17. Consider using rubocop -a --disable-uncorrectable to ease transition. (@marcandre)Metrics/CyclomaticComplexity not longer counts &. when repeated on the same variable. (@marcandre)Metrics/PerceivedComplexity now counts else in case statements, &., ||=, &&= and blocks known to iterate. Default bumped from 7 to 8. Consider using rubocop -a --disable-uncorrectable to ease transition. (@marcandre)Lint/InterpolationCheck marked as unsafe. (@marcandre)RuboCop::Cop::ParserDiagnostic mixin module. (@koic)Lint/NonDeterministicRequireOrder cop. (@biinari)Style/RedundantFileExtensionInRequire cop. (@fatkodima)Lint/DisjunctiveAssignmentInConstructor cop. (@fatkodima)bin/rubocop-profile and rake tasks. (@marcandre)Style/ArrayCoercion cop. (@fatkodima)Lint/DuplicateElsifCondition cop. (@fatkodima)Style/CaseLikeIf cop. (@fatkodima)Style/HashAsLastArrayItem cop. (@fatkodima)Style/HashLikeCase cop. (@fatkodima)expect_offense allows abbreviated offense messages. (@marcandre)Layout/EmptyLinesAroundAccessModifier when end immediately after access modifier. (@koic)Layout/MultilineArrayBraceLayout when comment is present after last element. (@shekhar-patil)Layout/MultilineMethodCallBraceLayout when comment is present before closing braces. (@shekhar-patil)Style/IfUnlessModifier bad precedence detection. (@tejasbubane)Style/AccessorGrouping to not register offense for accessor with comment. (@tejasbubane)Gemspec/RequiredRubyVersion. (@eugeneius)Style/PercentLiteralDelimiters when the source contains invalid characters. (@eugeneius).rubocop.yml files at all outside of the current project, unless they are personal configuration files and the project has no configuration. (@deivid-rodriguez)Layout/SpaceAroundMethodCallOperator cop to make it faster. (@fatkodima)of to AllowedNames of MethodParameterName cop. (@AlexWayfer)Layout/MultilineBlockLayout where spaces for a new line where not considered. (@knejad)--safe-autocorrect to --safe-auto-correct, which is compatible with RuboCop 0.86 and lower. (@koic)Style/BisectedAttrAccessor when accessors have different access modifiers. (@fatkodima)Style/AccessorGrouping when accessors have different access modifiers. (@fatkodima)Style/BisectedAttrAccessor when using attr_reader and attr_writer with splat arguments. (@fatkodima).rubocop.yml from personal folders to check for exclusions if given a custom configuration file. (@deivid-rodriguez)--auto-gen-config when running a cop who do not support auto-correction. (@koic)Lint/DeprecatedOpenSSLConstant auto-correction of OpenSSL::Cipher to use lower case, as some Linux-based systems do not accept upper cased cipher names. (@bdewater)Cop::Base is the new recommended base class for cops. (@marcandre)Style/AccessorGrouping cop. (@fatkodima)Style/BisectedAttrAccessor cop. (@fatkodima)AsciiConstants option for Naming/AsciiIdentifiers. (@fatkodima)Style/RedundantAssignment cop. (@fatkodima)CountAsOne option for code length related Metric cops. (@fatkodima)Lint/InterpolationCheck. (@koic)Style/IfUnlessModifierOfIfUnless. (@koic)Lint/SafeNavigationWithEmpty. (@koic)Lint/ParenthesesAsGroupedExpression in when using operators or chain functions. (@CamilleDrapier)Style/RedundantFetchBlock when using with Rails.cache. (@fatkodima)Style/RedundantFetchBlock when using #fetch with empty block. (@koic)Style/RedundantRegexpCharacterClass when using [\b]. (@owst)Style/RedundantRegexpCharacterClass when using a leading escaped ]. (@owst)Style/RedundantParentheses with hash literal as first argument to yield. (@karlwithak).rubocop.yml from personal folders to check for exclusions if there's a project configuration. (@deivid-rodriguez)Team, Commissioner, Corrector. Cop::Cop#corrections not completely compatible. See Upgrade Notes. (@marcandre)rubocop -a / --auto-correct no longer run unsafe corrections; rubocop -A / --auto-correct-all run both safe and unsafe corrections. Options --safe-autocorrect is deprecated. (@marcandre)ConsiderPunctuation setting is set to true. (@marcandre)Style/ClassVars cop now detects class_variable_set. (@biinari)::Const in various cops. (@biinari)Style/RedundantFetchBlock cop. (@fatkodima)Style/StructInheritance. (@tejasbubane)expect_offense templates add variable-length whitespace with _{foo}. (@eugeneius)Style/MultilineTernaryOperator. (@koic)Style/NestedTernaryOperator. (@koic)Lint/ConstantResolution cop. (@robotdana)Lint/RegexpAsCondition. (@koic)Lint/RaiseException. (@koic)Naming/MethodName: EnforcedStyle: camelCase and _ or i variables. (@avrusanov)Lint::FormatParameterMismatch when argument contains formatting. (@andrykonchin)Style/RedundantRegexpEscape with escaped delimiters. (@owst)Lint/FormatParameterMismatch when using named parameters with escaped %. (@koic)Style/RedundantRegexpCharacterClass when using interpolations. (@owst)Layout/EmptyLinesAroundAttributeAccessor when using attribute accessors in if ... else branches. (@koic)Layout/MultilineBlockLayout when missing newline before opening parenthesis ( for block body. (@koic)Style/YodaCondition when interpolation is used on the left hand side. (@koic)Metrics/CyclomaticComplexity now counts &., ||=, &&= and blocks known to iterate. Default bumped from 6 to 7. Consider using rubocop -a --disable-uncorrectable to ease transition. (@marcandre)Lint/RaiseException. (@koic)Lint/MixedRegexpCaptureTypes cop when using a regular expression that cannot be processed by regexp_parser gem. (@koic)Lint/SuppressedException when empty rescue block in do block. (@koic)Lint/SuppressedException when empty rescue block in defs. (@koic)Layout/HeredocIndentation auto-correct. (@jonas054)Lint::FormatParameterMismatch when it handles invalid format strings and add new offense. (@andrykonchin)CheckDefinitionPathHierarchy option for Naming/FileName. (@jschneid)Style/RedundantRegexpCharacterClass cop. (@owst)expect_offense to help format offense templates. (@marcandre)Style/RedundantRegexpEscape cop. (@owst)OnlyFor to the Bundler/GemComment cop. (@ric2b)AllowedNames option for Naming/ClassAndModuleCamelCase. (@tejasbubane)--display-only-failed that can be used with --format junit. Speeds up test report processing for large codebases and helps address the sorts of concerns raised at mikian/rubocop-junit-formatter #18. (@burnettk)Lint/MixedRegexpCaptureTypes cop. (@pocke)Lint/SuppressedException when empty rescue block in def. (@koic)Lint/DeprecatedOpenSSLConstant when deprecated OpenSSL constant is used in a block. (@koic)Lint/SuppressedException when empty rescue with comment in def. (@koic)inherit_gem in remote configs. (@CvX)Lint/DeprecatedOpenSSLConstant when using double quoted string argument. (@koic)--disable-uncorrectable would not update uncorrected code with rubocop:todo. (@rrosenblum)Lint/DeprecatedOpenSSLConstant when argument is a variable, method, or constant. (@koic)Layout/HeredocIndentation, so it only recommends using squiggly heredoc. (@bquorning)NodePattern and AST classes have been moved to the rubocop-ast gem. (@marcandre)Lint/DeprecatedOpenSSLConstant cop. (@bdewater)AllowAliasSyntax and AllowedMethods options for Layout/EmptyLinesAroundAttributeAccessor. (@koic)rake task "check_commit" will run rspec and rubocop on files touched by the last commit. Currently available when developing from the main repository only. (@marcandre)Lint/AmbiguousOperator when a method with no arguments is used in advance. (@koic)Lint/ParenthesesAsGroupedExpression when heredoc has a space between the same string as the method name and (. (@koic)Style/SlicingWithRange cop now supports any expression as its first index. (@zverok)Style/HashSyntax when using a return value uses return. (@koic)AllowComments logic in Lint/SuppressedException. (@jonas054)Layout/EmptyLinesAroundAttributeAccessor when attribute method is method chained. (@koic)Migration/DepartmentName when a disable comment contains an unexpected character for department name. (@koic)Layout/LineLength to 120 by default. (@koic)Style/AndOr. (@koic)EnforcedStyle for Style/DoubleNegation cop and allow double negation in contexts that use boolean as a return value. (@koic)rakefile file by default. (@jethrodaniel)Style/SlicingWithRange cop. (@zverok).simplecov file by default. (@robotdana)Lint/AmbiguousRegexpLiteral. (@koic)Lint/UselessAccessModifier. (@koic)Lint/AmbiguousOperator. (@koic)Style/IfWithSemicolon. (@koic)AllowComments option to Lint/EmptyWhen cop. (@koic)Lint/ParenthesesAsGroupedExpression. (@koic)Layout/ConditionPosition. (@koic)Lint/EnsureReturn. (@koic)Layout/EmptyLineAroundAttributeAccessor cop. (@koic)Style/FrozenStringLiteralComment to accept frozen_string_literal anywhere in leading comment lines. (@jeffcarbs)Style/CaseEquality when AllowOnConstant is true and the method receiver is implicit. (@rafaelfranca)--parallel and --ignore-parent-exclusion combination. (@jonas054)--parallel and --force-default-config combination. (@jonas054)Style/MultilineWhenThen when then required for a body of when is used. (@koic)rubocop --only or rubocop --except options without cop name argument. (@koic)Style/HashTransformKeys and Style/HashTransformValues cops when line break before to_h method. (@diogoosorio, @koic)Layout/SpaceAroundOperators with Layout/ExtraSpacing when using ForceEqualSignAlignment: true. (@koic)Style/IfUnlessModifier logic when tabs are used for indentation. (@jonas054)Lint/ParenthesesAsGroupedExpression when using an intended grouped parentheses. (@koic)Lint/LiteralAsCondition when using true literal in while and similar cases. (@koic)Style/GuardClause when using and or or operators for guard clause in then or else branches. (@koic)Style/GuardClause when assigning the result of a guard condition with else. (@koic)AllowInHeredoc option of Layout/TrailingWhitespace to true by default. (@koic)Layout/MultilineOperationIndentation. (@jonas054)--only-recognized-file-types is given. (@jonas054)Lint/BooleanSymbol as unsafe. (@laurmurclar)Style/OptionalArguments. (@koic)jaro_winkler gem, instead depending on did_you_mean. This may be a breaking change for RuboCop libraries calling NameSimilarity#find_similar_name. (@bquorning)wrap method. (@marcandre)Style/CaseEquality when the receiver is a constant. (@rafaelfranca)Style/ExponentialNotation cop. (@tdeo)Style/DisableCopsWithinSourceCodeDirective cop. (@egze)Layout/SpaceAroundMethodCallOperator cop. (@saurabhmaurya15)Lint/BooleanSymbol. (@knu)Lint/RaiseException when raising Exception with explicit namespace. (@koic)Lint/UriRegexp to register offense with array arguments. (@tejasbubane)Style/TrailingCommaInBlockArgs when lambda literal (->) has multiple arguments. (@koic)Lint/RaiseException when Exception without cbase specified under the namespace Gem by adding AllowedImplicitNamespaces option. (@koic)Style/IfUnlessModifier does not infinite-loop when auto-correcting long lines which use if/unless modifiers and have multiple statements separated by semicolons. (@alexdowad)ConfigLoader.default_configuration for the default config. (@hanachin)Layout/Tab cop to Layout/IndentationStyle. (@DracoAter)Lint/RaiseException cop. (@denys281)include? over member? in Style/CollectionMethods. (@dmolesUC)with_fixed_indentation option for Layout/ArrayAlignment cop. (@nikitasakov)Style/RedundantSort. (@koic)Layout/EmptyLineAfterGuardClause aware of case where and or or is used before keyword that break control (e.g. and return). (@koic)Layout/ElseAlignment cop. (@koic)Lint/SafeNavigationChain. (@koic)forbidden option to Style/ModuleFunction cop. (@weh)Lint/StructNewOverride cop. (@ybiquitous)Style/TrailingCommaInBlockArgs cop. (@pawptart)Style/EndBlock cop. (@tejasbubane)IgnoreNotImplementedMethods configuration to Lint/UnusedMethodArgument. (@tejasbubane)AllowModifiersOnSymbols configuration to Style/AccessModifierDeclarations. (@tejasbubane)Lint/BooleanSymbol cop. (@tejasbubane)IgnoredMethods configuration in Metrics/AbcSize, Metrics/CyclomaticComplexity, and Metrics/PerceivedComplexity cops. (@drenmi)Style/Lambda. (@koic)Style/OneLineConditional when one of the branches contains next keyword. (@koic)Style/InverseMethods auto-correct as incompatible with Style/SymbolProc. (@drenmi)Style/Documentation constant visibility declaration in namespace. (@AdrienSldy)Style/MultilineMethodCallIndentation when using Ruby 2.7's numbered parameter. (@koic)Style/HashTransformValues and Style/HashTransformKeys. (@tejasbubane)Layout/BlockEndNewline when } of multiline block without processing is not on its own line. (@koic)Layout/EndAlignment when a non-whitespace is used before the end keyword. (@koic)Lint/ErbNewArguments cop when inspecting ActionView::Template::Handlers::ERB.new. (@koic)Migrate/DepartmentName cop when inspecting an unexpected disabled comment format. (@koic)Style/OneLineConditional when one of the branches contains a self keyword. (@koic)Layout/MultilineMethodCallIndentation with key access to hash. (@tejasbubane)Style/HashEachMethods when receiver is implicit. (@koic)AllowComments option of Lint/SuppressedException to true by default. (@koic)Naming/MethodName now flags attr_reader/attr_writer/attr_accessor/attr. (@denys281)Lint/EndInMethod cop. (@tejasbubane)Style/NestedParenthesizedCalls cop for newline. (@tejasbubane)Style/RedundantCondition when the else branch contains a range. (@rrosenblum)Style/InverseMethods autofix leaving parenthesis. (@tejasbubane)Layout/LineLength cop when using lambda syntax that argument is not enclosed in parentheses. (@koic)` for descendant search. (@marcandre)AllowGemfileRubyComment configuration on Layout/LeadingCommentSpace. (@cetinajero)Style/HashTransformKeys and Style/HashTransformValues cops. (@djudd, @eugeneius)Migration/DepartmentName. (@koic)Layout/LineLength auto-correct now breaks up long lines with blocks. (@maxh)Style/HashEachMethods cop for Hash#each_key and Hash#each_value. (@jemmaissroff)BracesRequiredMethods parameter to Style/BlockDelimiters to require braces for specific methods such as Sorbet's sig. (@maxh)JUnitFormatter formatter based on rubocop-junit-formatter gem. (@koic)Steepfile to default Include list. (@ybiquitous)omit_parentheses style of Style/MethodCallWithArgsParentheses. (@gsamokovarov)undefined method on_numblock error when using Ruby 2.7's numbered parameters. (@hanachin)Layout/SpaceBeforeFirstArg when a vertical argument positions are aligned. (@koic)Style/MethodCallWithArgsParentheses that made --auto-gen-config crash. (@buehmann)Style/TernaryParentheses with Style/RedundantParentheses when using EnforcedStyle: require_parentheses_when_complex. (@koic)rubocop:disable comments on comment lines. (@jonas054)Style/OrAssignment when using elsif branch. (@koic)console from Lint/Debugger to prevent false positives. (@gsamokovarov)Style/BracesAroundHashParameters cop. (@pocke)Layout/EmptyLineBetweenDefs to help provide more context. (@rrosenblum)pp to allowed names of Naming/MethodParameterName cop in default config. (@masarakki)Lint/UselessSetterCall an "not safe" and improve documentation. (@jonas054)Migration/DepartmentName cop by default. (@koic)console and binding.console (rails/web-console) calls in Lint/Debuggers. (@gsamokovarov)pending status for new cops. (@Darhazer, @pirj)always_true style to Style/FrozenStringLiteralComment. (@parkerfinch, @gfyoung)Style/PercentLiteralDelimiters from changing %i literals that contain escaped delimiters. (@buehmann)Layout/SpaceBeforeBlockBraces when using with EnforcedStyle: line_count_based of Style/BlockDelimiters cop. (@koic)Style/YodaCondition accept __FILE__ == $0. (@koic)Gemspec/OrderedDependencies when using a local variable in an argument of dependent gem. (@koic)Style/NumericPredicate aware of ignored methods when specifying ignored methods. (@koic)Style/FrozenStringLiteralComment infinite loop when magic comments are newline-separated. (@pirj)Migration/DepartmentName when a disable comment contains a plain comment. (@koic)Style/MultilineWhenThen for when statement with then is an array or a hash. (@koic)Layout/MultilineBlockLayout removing trailing comma with single argument. (@pawptart)Migration/DepartmentName when there is space around : (e.g. # rubocop : disable). (@koic)Lint/NonDeterministicRequireOrder cop. (@mangara)EnforcedStyleForExponentOperator parameter to Layout/SpaceAroundOperators cop. (@khiav223577)Style/TrivialAccessors's AllowedMethods. (@movermeyer)Style/TrailingCommaInArguments when using an anonymous function with multiple line arguments with EnforcedStyleForMultiline: consistent_comma. (@koic)Style/BlockDelimiters cop and Layout/SpaceBeforeBlockBraces cop with EnforcedStyle: no_space when using multiline braces. (@koic)2 rather when 0 when the config file contains an unknown cop. (@jethroo)--disable-uncorrectable. (@tejasbubane)Layout/SpaceAroundOperators when using a Rational literal with / (e.g. 2/3r). (@koic)Style/Attr not flag offense for custom attr method. (@tejasbubane)Style/GuardClause crash. (@buehmann)LineLength cop from Metrics department to Layout department. (@koic)Style/RedundantReturn to inspect conditional constructs that are preceded by other statements. (@buehmann)Layout/SpaceInsideArrayLiteralBrackets to correct empty lines. (@ayacai115)Style/SpaceAroundKeyword allows :: after super. (@ozydingo)Style/RedundantParentheses when calling a method with safe navigation operator. (@koic)n % 2 == 2) for Style/EvenOdd. (@buehmann)Style/IfUnlessModifier respect all settings in Metrics/LineLength. (@jonas054)Whitelist and Blacklist with better alternatives. (@koic)SafeMode module. (@koic)Style/FormatStringToken ignore percent escapes (%%). (@buehmann)Layout/MultilineAssignmentLayout. (@gsamokovarov)Style/IfUnlessModifier respect rubocop:disable comments for Metrics/LineLength. (@jonas054)Style/SafeNavigation when an object check followed by a method call with a comment at EOL. (@koic)Style/MultilineWhenThen when the body of when branch starts with then. (@koic)Performance/StartWith and Performance/EndWith correct regexes that contain forward slashes. (@eugeneius)os to allowed names of Naming/UncommunicativeMethodParamName cop in default config. (@nijikon)merge to list of non-mutating methods. (@cstyles)Unneeded* cops to Redundant* (e.g., Style/UnneededPercentQ becomes Style/RedundantPercentQ). (@scottmatthewman)Style/FormatStringToken work inside hashes. (@buehmann)Style/SafeNavigation. (@rrosenblum)Layout/EmptyLineAfterGuardClause. (@gsamokovarov)Layout/IndentAssignment when multiple assignment with line breaks on each line. (@koic)Style/FormatStringToken now finds unannotated format sequences in printf arguments. (@buehmann)IgnoreCopDirectives to true for Metrics/LineLength. (@jdkaplan)Lint/SendWithMixinArgument cop. (@koic)Enabled, Safe, SafeAuto-Correct, and Auto-Correct keys in .rubocop.yml. (@unasuke)StyleGuideBaseURL per department. (@koic)remote_byebug to Lint/Debugger cop. (@riley-klingler).rubocop.yml. (@raymondfallon)pacman. (@crojasaragonez)IgnoredPatterns option for Naming/MethodName cop. (@koic)--disable-uncorrectable will now disable cops using rubocop:todo instead of rubocop:disable. (@desheikh)Style/RedundantParentheses on method calls where the first argument begins with a hash literal. (@halfwhole)Layout/SpaceInsideArrayLiteralBrackets properly handle tab-indented arrays. (@buehmann)Layout/SpaceInsideStringInterpolation skip over interpolations that start or end with a line break. (@buehmann)Lint/FormatParameterMismatch did not recognize named format sequences like %.2<name>f where the name appears after some modifiers. (@buehmann)Lint/NumberConversion when #to_i called without a receiver. (@koic)Style/TrailingCommaIn*Literal and Layout/Multiline*BraceLayout for arrays and hashes. (@buehmann)Style/FrozenStringLiteralComment match only true & false. (@tejasbubane)else in Style/ConditionalAssignment. (@jonas054)Layout/MultilineBlockLayout. (@jonas054)Style/BlockDelimiters offense when block result is assigned to an attribute. (@mvz)Lint/UnneededCopEnableDirective offenses undetected/uncorrected. (@jonas054)Style/AccessModifierDeclarations when access modifier name is used for hash literal value. (@koic)if/unless correctly in Lint/UselessAssignment. (@jonas054)Style/SafeNavigation cop for preserve comments inside if expression. (@tejasbubane)Style/BracesAroundHashParameters. (@jonas054)Style/RedundantSelf when receiver and multiple assigned lvalue have the same name. (@koic)Style/RedundantSelf when a self receiver is used as a method argument. (@koic)Style/NestedModifier when parentheses are required in method arguments. (@koic)Style/TernaryParentheses when only the closing parenthesis is used in the last line of condition. (@koic)Layout/IndentAssignment with Layout/IndentFirstArgument when using multiple assignment. (@koic)Style/OrAssignment cop when then branch body is empty. (@koic)Layout/SpaceInsideBlockBraces and Style/BlockDelimiters when using multiline empty braces. (@koic)Layout/EmptyLinesAroundAccessModifier and UselessAccessModifier when using method with the same name as access modifier around a method definition. (@koic)Style/StringHashKeys as unsafe. (@prathamesh-sonpatki)Style/VariableName aware argument names when invoking a method. (@koic)Style/IfUnlessModifier report and auto-correct modifier lines that are too long. (@jonas054)Style/FrozenStringLiteralComment no longer inserts an empty line after the comment. This is left to Layout/EmptyLineAfterMagicComment. (@buehmann)Style/FormatStringToken now detects format sequences with flags and modifiers. (@buehmann)IgnoredMethodPatterns option to IgnoredPatterns option for Style/MethodCallWithArgsParentheses. (@koic)Style/YodaCondition. (@koic)Style/TrailingMethodEndStatement work on more than the first def. (@buehmann)Lint/UnneededSplatExpansion when the splat expansion of Array.new with a block is assigned to a variable. (@rrosenblum)Layout/SpaceInsideStringInterpolation on interpolations with multiple statements. (@buehmann)Metrics/LineLength aware of shebang. (@koic)Layout/IndentationWidth when using EnforcedStyle: outdent of Layout/AccessModifierIndentation. (@koic)Style/ConditionalAssignment would swallow a nested if condition. (@buehmann)Style/ConstantVisibility work on non-trivial class and module bodies. (@buehmann)Layout/ExtraSpacing cop to handle nested consecutive assignments. (@jfelchner)Style/GuardClause. (@jonas054)SafeMode option. Users will need to upgrade rubocop-performance to 1.5.0+ before the SafeMode module is removed. (@rrosenblum)AllowDoxygenCommentStyle configuration on Layout/LeadingCommentSpace. (@anthony-robin)MultilineWhenThen cop. (@okuramasafumi)--disable-uncorrectable flag to generate rubocop:disable comments. (@vergenzt, @jonas054)Layout/RescueEnsureAlignment when def line is preceded with private_class_method. (@tatsuyafw)Style/MixinUsage when using inside multiline block and if condition is after include. (@koic)Layout/RescueEnsureAlignment on assigned blocks. (@tatsuyafw)Layout/MultilineMethodCallIndentation on method chains inside an argument. (@buehmann)Layout/Tab detect tabs between string literals. (@buehmann)Layout/SpaceInsideBlockBraces when EnforcedStyle: no_space with SpaceBeforeBlockParameters: false are set in multiline block. (@koic)Layout/IndentHeredoc would remove empty lines when auto-correcting heredocs. (@buehmann)Gemspec/RubyVersionGlobalsUsage cop. (@malyshkosergey)AllowIfModifier option to Style/IfInsideElse cop. (@koic)Style/FloatDivision that checks coercion. (@tejasbubane)Style/TernaryParentheses cop to allow safe navigation operator without parentheses. (@timon)Style/TernaryParentheses cop. (@parkerfinch)Lint/NumberConversion when #to_i called on a variable on a hash. (@koic)Style/MethodCallWithArgsParentheses. (@gsamokovarov)Style/WordArray with encoding: binary magic comment and non-ASCII string. (@pocke)Lint/DuplicatedKey when using endless range. (@koic)Style/WordArray to also consider words containing hyphens. (@fwitzke)Naming/RescuedExceptionsVariableName. (@pocke, @anthony-robin)Style/ConditionalAssignment when without else branch'. (@koic)Style/SafeNavigation when using unless nil? as a safeguarded'. (@koic)Style/FormatString if second argument to String#% is a variable. (@tejasbubane)Style/SafeNavigation when using unless nil? as a safeguarded'. (@koic)rubocop -R/--rails option. (@koic)EnforcedStyle: rails to EnabledStyle: indented_internal_methods for Layout/IndentationConsistency. (@koic)*, + and ? for repetitions. (@marcandre)Layout/AlignHash when mixed Hash styles are used. (@rmm5t)Naming/RescuedExceptionsVariableName cop. (@tejasbubane)Layout/EmptyLinesAroundBlockBody for multi-line method calls. (@eugeneius)Layout/MultilineMethodArgumentLineBreaks when bracket hash assignment on multiple lines. (@maxh)Layout/HeredocArgumentClosingParenthesis incompatible with Style/TrailingCommaInArguments. (@maxh)rubocop -R/--rails option. (@koic)Lint/PercentStringArray as unsafe. (@mikegee)Layout/AlignHash supports list of options. (@stoivo)IgnoreMethodPatterns config option to Style/MethodCallWithArgsParentheses. (@tejasbubane)EnforcedStyle to Layout/EmptyLinesAroundAccessModifier. (@koic)AllowComments option to Lint/HandleExceptions. (@tejasbubane)Lint/NumberConversion. (@Bhacaz)Style/PreferredHashMethods as unsafe. (@tejasbubane)Class.new to Lint/InheritException. (@houli)Style/NegatedUnless that checks for unless with negative condition. (@tejasbubane)Rails/TimeZone auto-correct Time.current to Time.zone.now. (@vfonic)Rails/TimeZone to prefer Time.zone.#{method} over other acceptable corrections. (@vfonic)Style/BlockDelimiters with braces_for_chaining style false positive, when chaining using safe navigation. (@Darhazer).rubocop file parsing. (@hoshinotsuyoshi)Lint/UnifiedInteger if TargetRubyVersion < 2.4. (@lavoiesl)Lint/NumberConversion from reporting error with Time/DateTime. (@tejasbubane)Style/StringHashKeys to allow string as keys for hash arguments to gsub methods. (@tejasbubane)Style/InverseMethods. (@dduugg)change_column_default in Rails/ReversibleMigration cop. (@tejasbubane)Layout/EmptyLineAfterGuardClause when guard clause is a ternary operator. (@koic)Time.zone.current with Time.zone.today on Rails::Date cop message. (@vfonic)EnforcedStyle to squiggly option for Layout/IndentHeredoc and auto_detection option is removed. (@koic)EnforcedStyle to always option for Style/FrozenStringLiteralComment and when_needed option is removed. (@koic)unicode/display_width dependency version 1.6.0. (@tagliala)Style/SafeNavigation from crashing. (@RicardoTrindade)Style/RedundantParentheses when enclosed in parentheses at while-post or until-post. (@koic)Style/RedundantFreeze when freezing the result of String#*. (@bquorning)Naming/RescuedExceptionsVariableName to also rename all references to the variable. (@Darhazer)Layout/IndentFirstParameter cop. (@drenmi)Style/MixinUsage when using inside block and if condition is after include. (@koic)Style/Next and Style/SafeNavigation. (@hoshinotsuyoshi)Style/BlockDelimiters to properly check if the node is chained when braces_for_chaining is set. (@att14)always_braces to Style/BlockDelimiter. (@iGEL)<>. (@marcandre)--init option for generate .rubocop.yml file in the current directory. (@koic)Layout/HeredocArgumentClosingParenthesis cop. (@maxh)Metrics/LineLength. (@maxh)Layout/IndentFirstParameter. (@maxh)Layout/FirstMethodArgumentLineBreak aware of calling using super. (@koic)Lint/HeredocMethodCallPosition cop. (@maxh)Rails/RedundantAllowNil when with interpolations. (@Blue-Pix)Rails/ActiveRecordOverride when no parent_class present. (@diachini)Rails/Validation. (@jmanian)Rails/ReflectionClassName to use string interpolation for class_name. (@r7kamura)Style/HashSyntax cop when a hash key is an interpolated string and EnforcedStyle is ruby19_no_mixed_keys. (@tatsuyafw)Naming/RescuedExceptionsVariableName would handle an only first rescue for multiple rescue groups. (@tatsuyafw)Style/InverseMethods and Style/Not. (@hoshinotsuyoshi)Layout/AccessModifierIndentation should ignore access modifiers that apply to specific methods. (@deivid-rodriguez)Lint/Lambda and Lint/UnusedBlockArgument. (@koic)Style/SafeNavigation when a modifier if is safe guarding a method call being passed to break, fail, next, raise, return, throw, and yield. (@rrosenblum)Lint/LiteralInInterpolation if contains array percent literal. (@yakout)Style/InverseMethods when using BasicObject#!. (@koic)Naming/RescuedExceptionsVariableName. (@anthony-robin)_ in Naming/RescuedExceptionsVariableName cop. (@anthony-robin)--auto-gen-only-exclude to the command outputted in rubocop_todo.yml if the option is specified. (@dvandersluis)Lint/UnderscorePrefixedVariableName cop to be configured to allow use of block keyword args. (@dduugg)Layout/FirstParameterIndentation to Layout/IndentFirstArgument. (@maxh)Layout/AlignParameters into Layout/AlignArguments. (@maxh)IndentArray and IndentHash to IndentFirstArrayElement and IndentFirstHashElement. (@maxh)Rails/RedundantAllowNil when not using both allow_nil and allow_blank. (@koic)Rails/ActiveRecordOverride that checks for overriding Active Record methods instead of using callbacks. (@elebow)Rails/RedundantAllowNil that checks for cases when allow_blank makes allow_nil unnecessary in model validations. (@elebow)Naming/RescuedExceptionsVariableName cop. (@AdrienSldy)Naming/UncommunicativeMethodParamName account for param names prefixed with underscores. (@thomthom)Rails/RedundantReceiverInWithOptions when the body is empty. (@ericsullivan)Style/BlockComments when the file is missing a trailing blank line. (@ericsullivan)Lint/ToJSON when there are no to_json arguments. (@koic)StyleGuideBaseURL for Layout/ClassStructure. (@aeroastro)Rails/LinkToBlank auto-correct bug when using symbol for target. (@r7kamura)Rails/LinkToBlank when rel is a symbol value. (@r7kamura)IncludedMacros param to default rubocop config for Style/MethodCallWithArgsParentheses. (@maxh)Rails/Present or Rails/Blank in an unless else context when Style/UnlessElse is enabled. (@rrosenblum)LstripRstrip from Performance to Style department and rename it to Strip. (@anuja-joshi)Struct.new in Style/StructInheritance. (@XrXr)Performance/RedundantSortBy, Performance/UnneededSort and Performance/Sample to the Style department. (@bbatsov)AllowBracesOnProceduralOneLiners option to fine-tune Style/BlockDelimiter's semantic mode. (@davearonson)AllowBeforeTrailingComments option on Layout/ExtraSpacing cop. (@davearonson)Lint/SafeNavigationWithEmpty checks for foo&.empty? in conditionals. (@rspeicher)Style/ConstantVisibility cop for enforcing visibility declarations of class and module constants. (@drenmi)Lint/ToJSON cop to enforce an argument when overriding #to_json. (@allcentury)Rails/TimeZone. (@dcluna).... (@marcandre)Style/RedundantSelf when the method is also defined on Kernel. (@mikegee)Rails/LinkToBlank when _blank is a symbol. (@Intrepidd)Layout/IndentationWidth and Layout/IndentationConsistency when bad modifier indentation before good method definition. (@koic)Style/TrivialAccessors when using trivial reader/writer methods at the top level. (@koic)Style/ConditionalAssignment, Style/IdenticalConditionalBranches, Lint/ElseLayout, and Layout/IndentationWidth with empty braces. (@pocke)Style/SymbolArray with array contains interpolation when EnforcedStyle is brackets. (@pocke)Layout/SpaceAroundBlockParameters with EnforcedStyleInsidePipes: :space. (@pocke)Style/NumericLiterals on a literal that contains spaces. (@pocke)Style/Lambda with no-space argument. (@pocke)Style/NumericLiterals on numeric literal with exponent. (@pocke)Rails/Validation when method arguments are enclosed in parentheses. (@koic)Naming/ConstantName when assigning a frozen range. (@drenmi)Metrics/AbcSize. Comparison methods and else branches add to the comparison count. (@rrosenblum)Rails/ReflectionClassName to use symbol argument for class_name. (@unasuke)Layout/ClassStructure to allow grouping macros by their visibility. (@gprado)Ctrl-C handling to RuboCop's loop and simplify it to a single phase. (@deivid-rodriguez)$stdout/$stderr and STDOUT/STDERR method calls to Rails/Output. (@elebow)iterator? to deprecated methods and prefer block_given? instead. (@tejasbubane)powerpack dependency. (@dduugg)Metrics/BlockLength cop. (@koic)Style/RedundantFreeze aware of methods that will produce frozen objects. (@rrosenblum)$stderr.puts with no arguments. (@luciamo)Style/MutableConstant that will freeze all constants, rather than just literals. (@rrosenblum)IncludedMacros to Style/MethodCallWithArgsParentheses to allow including specific macros when IgnoreMacros is true. (@maxh)Style/MethodCallWithArgsParentheses omit_parentheses. (@gsamokovarov)Style/MethodCallWithArgsParentheses omit_parentheses. (@gsamokovarov)Style/RaiseArgs auto-correction breaking in contexts that require parentheses. (@drenmi)Style/OneLineConditional from breaking on retry and break keywords. (@drenmi)Style/TrailingCommaInArgument from breaking when a safe method call is chained on the offending method. (@drenmi, @hoshinotsuyoshi).rubocop.yml. (@pocke)Style/ModuleFunction as SafeAuto-Correct: false and disable auto-correct by default. (@dduugg)Rails/ReflectionClassName cop. (@Bhacaz)AllowParenthesesInCamelCaseMethod option on Style/MethodCallWithArgsParentheses omit_parentheses. (@dazuma)Layout/RescueEnsureAlignment for non-local assignments. (@marcotc)Style/EmptyLiteral when Hash.new is passed as the first argument to super. (@rrosenblum)Layout/ClosingParenthesisIndentation when first argument is multiline. (@antonzaytsev)Rails/Validation auto-correction. (@r7kamura)Style/UnneededCondition when conditional has the unless form. (@mvz)Layout/IndentationWidth with Layout/EndAlignment set to start_of_line. (@dischorde, @siegfault, @mhelmetag)Naming/MemoizedInstanceVariableName on method starts with underscore. (@pocke)Style/OneLineConditional when then branch has no body. (@koic)TrailingComma regression where heredoc with commas caused false positives. (@abrom)Rails/LinkToBlank when link_to method arguments are enclosed in parentheses. (@koic):native line ending for Layout/EndOfLine on JRuby. (@enkessler)Style/LineEndConcatenation is now known to be unsafe for auto-correct. (@jaredbeck)Style/SymbolProc as unsafe for auto-correct. (@drenmi)Style/CommentedKeyword allow the :yields: RDoc comment. (@bquorning)Lint/DisjunctiveAssignmentInConstructor when it finds an empty constructor. (@rmm5t)Rails/RelativeDateConstant. (@rrosenblum)Style/WordArray and Style/SymbolArray when all elements are on separate lines and there is a trailing comment after the closing bracket. (@rrosenblum)Layout/ClosingParenthesesIndentation when there are no arguments. (@rrosenblum)Rails/LinkToBlank. (@Intrepidd)Rails/IgnoredSkipActionFilterOption cop. (@wata727)Style/YodaCondition cop to be configured to enforce yoda conditions. (@tejasbubane)Rails/BelongsTo cop with auto-correct for Rails >= 5. (@petehamilton)Rails/LinkToBlank detection to allow rel: 'noreferrer. (@fwininger)Naming/ConstantName cop when rhs is a conditional expression. (@tatsuyafw)Lint/ShadowedException cop. (@tatsuyafw)Style/TernaryParentheses. (@jonas054)Style/RegexpLiteral cop when there is string interpolation. (@roooodcastro)Style/SafeNavigation when a method call safeguarded with a negative check for the object. (@koic)Lint/SafeNavigation complaining about use of to_d. (@tejasbubane)Naming/PredicateName suggesting invalid rename. (@tejasbubane)Style/DocumentationMethod cop to recognize documentation comments for def inline with module_function. (@tejasbubane)Style/EmptyLiteral when Hash.new is passed as the first argument to super. (@rrosenblum)Performance/RangeInclude as unsafe because Range#include? and Range#cover? are not equivalent. (@koic)FlipFlop cop from Style to Lint department because flip-flop is deprecated since Ruby 2.6.0. (@koic)Rails/LinkToBlank checks for link_to calls with target: '_blank' and no rel: 'noopener'. (@Intrepidd)Lint/DisjunctiveAssignmentInConstructor checks constructors for disjunctive assignments that should be plain assignments. (@jaredbeck)--exclude-limit in combination with --auto-gen-only-exclude. (@jonas054)in_time_zone instead of deprecated to_time_in_current_zone. (@nadiyaka)--auto-gen-config when Metrics/LineLength cop is disabled. (@tom-lord)Style/TrailingCommaInHashLiteral/Style/TrailingCommaInArrayLiteral when there is a comment in the last line. (@bayandin)Layout/EmptyLinesAroundAccessModifier when at the end of specifying a superclass is missing blank line. (@koic)Layout/TrailingCommaInArguments when a line break before a method call and EnforcedStyleForMultiline is set to consistent_comma. (@koic)Layout/AccessModifierIndentation work for dynamic module or class definitions. (@deivid-rodriguez)Style/MethodCallWithArgsParentheses omit_parentheses enforced style after safe navigation call. (@gsamokovarov)Style/MethodCallWithArgsParentheses omit_parentheses enforced style while splatting the result of a method invocation. (@gsamokovarov)Style/MethodCallWithArgsParentheses omit_parentheses enforced style for calls with regexp slash literals argument. (@gsamokovarov)Style/MethodCallWithArgsParentheses omit_parentheses enforced style for default argument value calls. (@gsamokovarov)Style/MethodCallWithArgsParentheses omit_parentheses enforced style for argument calls with braced blocks. (@gsamokovarov)Rails/OutputSafety when the receiver is a non-interpolated string literal. (@amatsuda)Style/AccessModifierIndentation not handling arbitrary blocks. (@deivid-rodriguez)extend self into module_function when there are private methods. (@Ruffeng)git. (@AlexWayfer)Style/RegexpLiteral. (@r7kamura)Style/Lambda. (@r7kamura)Style/MethodCallWithArgsParentheses cop. (@gsamokovarov)Performance/OpenStruct checks for OpenStruct.new calls. (@xlts)Layout/RescueEnsureAlignment error on assigned blocks. (@gmcgibbon)Lint/UselessAssignment when using a variable in a module name. (@itsWill)--auto-gen-config and --config FILE correctly. (@jonas054)--auto-gen-config in a subdirectory work. (@jonas054)unknown keywords error when using Psych.safe_load with Ruby 2.6.0-preview2. (@koic)Style/BracesAroundHashParameters when the opening brace is before the first hash element at same line. (@koic)yield and super like regular method calls in Style/AlignHash. (@mvz)Style/InfiniteLoop. (@jonas054)Style/TrailingCommaInArguments. (@jonas054)coding variable. (@akihiro17)inherit_mode parameter to individual cop configurations. (@maxh)Layout/IndentationWidth when setting EnforcedStyle: rails of Layout/IndentationConsistency and method definition indented to access modifier in a singleton class. (@koic)Lint/FormatParameterMismatch when using (digit)$ flag. (@koic)Style/UnneededCondition when if condition and then branch are the same and it has no else branch. (@koic)Style/FrozenStringLiteral when a file contains only a shebang. (@takaram)Style/EmptyCaseCondition when used as an argument of a method. (@koic)Style/RaiseArgs when an exception object is assigned to a local variable. (@koic)Lint/UselessAccessModifier when using private_class_method. (@dduugg)Performance/RedundantMerge raises an error on a sole double splat argument passed to merge!. (@mmedal)if nodes even if the first branch is empty. (@bquorning)Layout/CommentIndentation to avoid unnecessary iterations for rubocop -a. (@jonas054)--auto-gen-config when individual cops have regexp literal exclude paths. (@maxh)--safe and --safe-auto-correct options. (@Darhazer)--auto-gen-only-exclude. (@Ana06, @jonas054)VersionAdded meta data to config/default.yml when running rake new_cop. (@koic)Whitelist config to Rails/SkipsModelValidations rule. (@DiscoStarslayer)Rails/ReversibleMigration when using variable assignment. (@koic, @scottmatthewman)Style/RedundantFreeze and a false negative for Style/MutableConstant when assigning a regexp object to a constant. (@koic)Style/RedundantFreeze when assigning a range object to a constant. (@koic)Rails/ReversibleMigration when block argument is empty. (@koic)LineLength cop for tab-indented code. (@AlexWayfer)key option in Layout/AlignHash cop. (@albaer)Style/MethodCallWithoutArgsParentheses to highlight the closing parentheses in addition to the opening parentheses. (@rrosenblum)Rails/HasManyOrHasOneDependent when using associations of Active Resource. (@tejasbubane, @koic)Style/For when setting EnforcedStyle: each and for dose not have do or semicolon. (@autopp)Layout/EmptyLineAfterGuardClause when guard clause including heredoc. (@koic)AllowURI option for Metrics/LineLength cop with disabled Layout/Tab cop. (@AlexWayfer)Metrics/BlockLength into the respective length cops. (@drenmi)Style/ZeroLengthPredicate false positives when inspecting Tempfile, StringIO, and File::Stat objects. (@drenmi)Layout/EmptyLinesAroundAccessModifier and Layout/EmptyLinesAroundAccessModifier when specifying a superclass that breaks the line. (@koic)Style/IfUnlessModifier when using named capture. (@drenmi)Style/Semicolon from breaking on single line if-then-else in assignment. (@drenmi)Rails/HasManyOrHasOneDependent when an Active Record model does not have any relations. (@koic)Style/For when setting EnforcedStyle: each with range provided to the for loop without a do keyword or semicolon and without enclosing parenthesis. (@lukasz-wojcik)Layout/RescueEnsureAlignment when using inline access modifier. (@andrew-aladev)Rails/FindEach. (@Knack)Naming/FileName when investigating gemspecs. (@kddeisz)Naming/FileName when investigating dotfiles. (@sinsoku)Style/EmptyCaseCondition auto-correction removes comment between case and first when. (@koic)Style/RedundantBegin when calling super with a block. (@eitoball)Layout/EmptyLineAfterGuardClause when guard clause is after heredoc including string interpolation. (@koic)Style/MultilineMethodSignature. (@drenmi)Layout/EmptyLineAfterGuardClause cop when if condition is after heredoc. (@koic)Lint/UnreachableCode detect exit, exit! and abort. (@hoshinotsuyoshi)#=== from Naming/BinaryOperatorParameterName. (@zverok)+ to allowed file names of Naming/FileName. (@yensaki)PercentLiteralCorrector class from PercentLiteral mixin. (@ryanhageman)Bundler/GemComment cop. (@sunny)IgnoredMethods option to Style/NumericPredicate cop. (@AlexWayfer)--display-only-fail-level-offenses to only output offenses at or above the fail level. (@robotdana)Style/For. (@rrosenblum)AllowImplicitReturn option to Rails/SaveBang cop. (@robotdana)comparison style to Style/NilComparison. (@khiav223577)Style/MultilineMethodSignature cop. (@drenmi)Performance/ChainArrayAllocation cop. (@schneems)Layout/EmptyLinesAroundClassBody aware of specifying a superclass that breaks the line. (@koic)Style/DateTime not detecting #to_datetime. It can be configured to allow this. (@bdewater)Naming/FileName when Include of AllCops is the default setting. (@koic)Layout/MultilineOperationIndentation. (@jonas054)Layout/ClosingParenthesisIndentation when method arguments are empty with newlines. (@tatsuyafw)Layout/AccessModifierIndentation when using access modifiers with arguments within nested classes. (@gmalette)Style/IfUnlessModifier cop for disabled Layout/Tab cop when there is no IndentationWidth config. (@AlexWayfer)AllowURI option of Metrics/LineLength cop for files with tabs indentation. (@AlexWayfer)Style/UnneededCondition when using operator method higher precedence than ||. (@koic)Lint/ShadowedArgument. (@jonas054)Layout/MultilineHashBraceLayout and Layout/MultilineArrayBraceLayout auto-correct syntax error when there is a comment on the last element. (@bacchir)Style/BracesAroundHashParameters auto-correct syntax error when there is a trailing comma. (@bacchir)Style/RedundantBegin aware of stabby lambdas. (@drenmi)Naming/PredicateName. (@sunny)Style/EmptyCaseCondition when using return in when clause and assigning the return value of case. (@koic)Rails/Delegate. (@sunny)Style/WordArray when setting EnforcedStyle: brackets and using string interpolation in %W literal. (@koic)Lint/RescueEnsureAlignment when end is misaligned. The alignment and message are now based on the beginning position rather than the end position. (@rrosenblum)Date usage in Style/DateTime. (@deivid-rodriguez)Rails/FindEach cop. Makes the cop also check for the following scopes: eager_load, includes, joins, left_joins, left_outer_joins, preload, references, and unscoped. (@repinel)db to allowed names of Naming/UncommunicativeMethodParamName cop in default config. (@mkenyon)Lint/DuplicateMethods to include the method name. (@rrosenblum)rubocop --auto-gen-conf if the todo file is successfully created even if there are offenses. (@MagedMilad)Rails/RelativeDateConstant by default. (@koic)*) to match the hidden file. (@koic)Style/For now highlights the entire statement rather than just the keyword. (@rrosenblum)Performance/CaseWhenSplat and its auto-correction by default. (@rrosenblum)Layout/EmptyLineAfterGuardClause cop by default. (@koic)Style/DateTime has been moved to disabled by default. (@deivid-rodriguez)Layout/IndentationWidth when multiple modifiers are used in a block and a method call is made at end of the block. (@koic)Naming/MemoizedInstanceVariableName cop to allow methods to have leading underscores. (@kenman345)Layout/ClassStructure when there is a comment in the macro method to be auto-correct. (@koic)Lint/OrderedMagicComments when using { encoding: Encoding::SJIS } hash object after frozen_string_literal magic comment. (@koic)ip to allowed names of Naming/UncommunicativeMethodParamName cop in default config. (@nijikon)Style/MethodCallWithArgsParentheses when arguments are method calls. (@maxh)Style/RedundantParentheses with hash literal as first argument to super. (@maxh)Gemspec/OrderedDependencies when using method call to gem names in gemspec. (@koic)Rails/BulkChangeTable aware of variable table name. (@wata727)Layout/MultilineAssignmentLayout cop when using multi-line block defines on separate lines. (@koic)Style/IpAddresses cop. (@dvandersluis)Naming/MemoizedInstanceVariableName cop to allow leading underscores. (@leklund)EnforcedStyleForLeadingUnderscores to Naming/MemoizedInstanceVariableName cop to allow leading underscores. (@leklund)Performance/Sample will now register an offense when using shuffle followed by at or slice. (@rrosenblum)Layout/IndentationWidth when multiple modifiers and def are on the same line. (@tatsuyafw)Layout/ClosingHeredocIndentation when heredoc content is outdented compared to the closing. (@koic)Style/UnneededCondition. (@rrosenblum)Lint/UnneededCondition when using if_branch in else branch. (@koic)Lint/ShadowedArgument when reassigning to splat variable. (@koic)Layout/LeadingBlankLines is the first cop to act. (@Vasfed)Rails/BulkChangeTable aware of string table name. (@wata727)Style/MultipleComparison when multiple comparison is not part of a conditional. (@koic)Lint/RedundantWithObject error on missing parameter to each_with_object. (@Vasfed)Rails/CreateTableWithTimestamps cop. (@drn)Style/SymbolProc when using block with adding a comma after the sole argument. (@koic)<< as a kind of assignment operator in Layout/EndAlignment. (@jonas054)Performance/InefficientHashSearch when a method by itself and include? method are method chaining. (@koic)rake repl task. (@koic)Lint/UselessAccessModifier now warns when private_class_method is used without arguments. (@Darhazer)refine by default from Metrics/BlockLength cop. (@kddeisz)IndentationWidth of Layout/Tab for other cops. (@AlexWayfer)Layout/ClosingHeredocIndentation from raising an error on << heredocs. (@dvandersluis)Layout/ClosingHeredocIndentation from raising an error on heredocs containing only a newline. (@drenmi)Layout/IndentationConsistency cop triggered by an empty expression string interpolation. (@alexander-lazarov)Style/MethodCallWithArgsParentheses from raising an error in certain cases. (@drenmi)inherit_mode directive. (@jonas054)Layout/IndentationWidth when an access modifier section has an invalid indentation body. (@tatsuyafw)Layout/IndentationConsistency should still register an offense for private methods. (@jaredbeck)Rails/BulkChangeTable. (@wata727)Style/UnneededCondition cop accepts a case of condition and if_branch are same when using elsif branch. (@koic)Rails/BulkChangeTable cop. (@wata727)Style/AccessModifierDeclarations cop. (@brandonweiss)Style/UnneededCondition cop. (@balbesina)Layout/ClosingHeredocIndentation cop. (@siegfault)slashes style to Rails/FilePath since Ruby accepts forward slashes even on Windows. (@sunny)Layout/LeadingBlankLines checks for empty lines at the beginning of a file. (@rrosenblum)Style/SymbolArray and Style/WordArray not working on arrays of size 1. (@TikiTDO)Rails/AssertNot to allow it to have failure message. (@koic)headers or env keyword arguments in Rails/HttpPositionalArguments. (@rrosenblum)Style/BracesAroundHashParameters auto-correct going past the end of the file when the closing curly brace is on the last line of a file. (@EiNSTeiN-)Style/FrozenStringLiteralComment would be added to the second line if the first line is empty. (@rrosenblum)Layout/SpaceInsideReferenceBrackets aware of no_space when using nested reference brackets. (@koic)Style/MixinGrouping when method named include accepts block. (@Darhazer)--fix-layout/-x command line alias. (@scottmatthewman)Lint/SplatKeywordArguments cop. (@koic)httpdate to accepted Rails/TimeZone methods. (@cupakromer)xmlschema to accepted Rails/TimeZone methods. (@koic)rake repl task to bin/console command. (@koic)inherit_mode work for default configuration too. (@jonas054)unicode/display_width. (@nroman-stripe)Performance/InefficientHashSearch cop. (@JacobEvelyn)Rails/RefuteMethods cop. (@koic)Rails/AssertNot cop. (@composerinteralia)Layout/ClosingParenthesisIndentation detection including method chaining. (@jfelchner)consistent_relative_to_receiver style option to Layout/FirstParameterIndentation. (@jfelchner)AR::Migration#up_only for Rails/ReversibleMigration cop. (@koic)Lint/ErbNewArguments cop. (@koic)Lint/SplatKeywordArguments cop. (@koic)Include, Exclude and the new RubyInterpreters parameters for file selection. (@jonas054)Style/EmptyMethod which concatenated the method name and first argument if no method def parentheses are used. (@thomasbrus)Rails/SaveBang when using negated if. (@Edouard-chin)Lint/SafeNavigationChain not detecting chained operators after block. (@Darhazer)Lint/SafeNavigationConsistency registers multiple offenses for the same method call. (@rrosenblum)Style/CommentAnnotation reporting only the first of multiple consecutive offending lines. (@svendittmer)Lint/SafeNavigationConsistency when there is code around the condition. (@rrosenblum)Rails/HasManyOrHasOneDependent when using nested with_options. (@koic)--stdin always treats input as Ruby source irregardless of filename. (@PointlessOne)Style/MethodCallWithArgsParentheses adding extra parentheses if the method argument was already parenthesized. (@dvandersluis)AllCops/Include were not inspected when passing the file name as an option. (@drenmi)Lint/PercentStringArray and Lint/PercentSymbolArray when the inspected file is binary encoded. (@akhramov)nil responds to in Lint/SafeNavigationConsistency. (@rrosenblum)Lint/LiteralInInterpolation if contains numbers. (@koic)Rails/CreateTableWithTimestamps when using hash options. (@wata727)Lint/UnneededCopEnableDirective for instruction '# rubocop:enable all'. (@balbesina)Rails/HttpPositionalArguments to use session instead of header. (@rrosenblum)Style/MethodMissing into two cops, Style/MethodMissingSuper and Style/MissingRespondToMissing. (@rrosenblum)AllowInMultilineConditions option to Style/ParenthesesAroundCondition cop. (@Darhazer)Layout/SpaceInsideReferenceBrackets when assigning a reference bracket to a reference bracket. (@joshuapinter)--auto-correct. (@jonas054)try! to the list of whitelisted methods for Lint/SafeNavigationChain and Style/SafeNavigation. (@rrosenblum)Style/EmptyLineAfterGuardClause cop to Layout department. (@koic)Performance/UnneededSort cop. (@parkerfinch)Lint/SafeNavigationConsistency cop. (@rrosenblum)Performance/RegexpMatch cop not correcting negated match operator. (@bdewater):class_name option in Rails/InverseOf cop. (@bdewater)Style/SymbolArray and Style/WordArray for multiline Arrays. (@istateside)Rails/InverseOf cop allowing inverse_of: nil to opt-out. (@bdewater)Lint/ShadowedArgument false positive with shorthand assignments. (@akhramov)Naming/HeredocDelimiterNaming blacklist patterns. (@mcfisch)Performance/RegexpMatch to produce code that safe guards against the receiver being nil. (@rrosenblum)Rails/HttpStatus ignoring hash order to fix false negative. (@pocke)Style/EmptyLineAfterGuardClause when guard clause is after heredoc. (@koic)Style/EmptyLineAfterGuardClause when guard clause is after heredoc argument. (@koic)Style/UnpackFirst false positive of unpack('h*').take(1). (@parkerfinch)Style/FrozenStringLiteralComment auto-correction to insert a new line between the comment and the code. (@rrosenblum)Lint/Void not detecting void context in blocks with single expression. (@Darhazer)String#delete_{prefix,suffix} to Lint/Void cop. (@bdewater)by, on, in and at to allowed names of Naming/UncommunicativeMethodParamName cop in default config. (@AlexWayfer)EnforcedStyle option to Layout/SpaceInsideParens, allowing you to enforce spaces inside of parentheses. (@joshuapinter)Metrics/BlockLength's ExcludedMethods configuration option. (@akhramov)IgnoredMethods option to Style/MethodCallWithoutArgsParentheses cop. (@Darhazer)Style/OptionHash aware of implicit parameter passing to super. (@Wei-LiangChew)Rails/HttpStatus cop. (@anthony-robin)Style/UnpackFirst cop. (@bdewater)Performance/StartWith and EndWith cops to look for Regexp#match?. (@bdewater)Naming/UncommunicativeXParamName cops. (@jlfaber)Layout/ElseAlignment for rescue/else/ensure inside do/end blocks. (@YukiJikumaru)Style/Documentation :nodoc: for compact-style nested modules/classes. (@ojab)Bundler/OrderedGems when a group includes duplicate gems. (@colorbox)--fail-fast. (@mmyoji)Style/FormatStringToken when using placeholder arguments in format method. (@koic)Style/InverseMethods when comparing constants with <, >, <=, or >=. If the code is being used to determine class hierarchy, the correction might not be accurate. (@rrosenblum)Style/TrivialAccessors auto-correction for def with private. (@pocke)Style/SafeNavigation does not auto-correct all chained methods resulting in a Lint/SafeNavigationChain offense. (@rrosenblum)UncommunicativeName cops. (@pocke)Layout/EmptyComment when the empty comment appears on the same line as code. (@rrosenblum)Style/EmptyLineAfterGuardClause when guard clause is before rescue or ensure. (@koic)Style/EmptyLineAfterGuardClause when guard clause is before else. (@koic)Naming/ConstantName when using conditional assignment. (@drenmi)Naming/UncommunicativeMethodParamName add to to allowed names in default config. (@unused)--debug. (@jonas054)Layout/SpaceInsideArrayLiteralBrackets when contains an array literal as an argument after a heredoc is started. (@koic)gems.locked or Gemfile.lock to determine the best TargetRubyVersion when it is not specified in the config. (@roberts1000)Style/InlineComment for inline comments which enable or disable rubocop cops. (@jfelchner)IndentHeredoc message for Ruby 2.3 when using <<~ operator with invalid indentation. (@hamada14)Naming/UncommunicativeBlockParamName cop. (@garettarrowood)Naming/UncommunicativeMethodParamName cop. (@garettarrowood)Lint/UnneededCopEnableDirective cop. (@garettarrowood)Lint/BigDecimalNew cop. (@koic)Style/TrailingBodyOnClass cop. (@garettarrowood)Style/TrailingBodyOnModule cop. (@garettarrowood)Style/TrailingCommaInArrayLiteral cop. (@garettarrowood)Style/TrailingCommaInHashLiteral cop. (@garettarrowood)Security/Open cop. (@mame)EnforcedStyleForEmptyBrackets configuration to Layout/SpaceInsideReferenceBrackets. (@garettarrowood)Style/ModuleFunction. (@garettarrowood)--no-auto-gen-timestamp CLI option suppresses the inclusion of the date and time it was generated in auto-generated config. (@dominicsayers)Layout/EmptyComment cop. (@koic)inherit_mode for merging arrays. (@leklund).axlsx file by default. (@georf)Lint/OrderedMagicComments cop. (@koic)Style/ExpandPathArguments cop. (@koic)beginning_only and ending_only style options to Layout/EmptyLinesAroundClassBody cop. (@jmks).arb file by default. (@deivid-rodriguez)gems.locked or Gemfile.lock to determine the best TargetRailsVersion when it is not specified in the config. (@roberts1000)Naming/MemoizedInstanceVariableName cop. (@satyap)Style/EmptyLineAfterGuardClause cop. (@unkmas)Rails/ActiveRecordAliases cop. (@elebow)Lint/IndentationWidth when Lint/EndAlignment is configured with start_of_line. (@brandonweiss)Performance/Casecmp auto-correction. (@walinga)Style/TrailingMethodEndStatement. (@garettarrowood)Style/TrailingBodyOnMethodDefinition auto-correction. (@garettarrowood)Metric/LineLength false offenses for URLs in double quotes. (@garettarrowood)Layout/EmptyLinesAroundArguments false positives for inline access modifiers. (@garettarrowood)Layout/EmptyLinesAroundArguments false positives for multiline heredoc arguments. (@garettarrowood)Rails/Presence false detection of receiver for locally defined blank? & present? methods. (@garettarrowood)Lint/NestedPercentLiteral when percent characters are nested. (@asherkach)Lint/InterpolationCheck false positives on escaped interpolations. (@pocke)Style/SymbolArray and Style/WordArray auto-correct. (@flyerhzm)Rails/Delegate's false positive with a method call with arguments. (@pocke)Style/SafeNavigation when safe guarding more comparison methods. (@rrosenblum)Style/SafeNavigation will add safe navigation to all methods in a method chain. (@rrosenblum)Style/SafeNavigation if there is an unsafe method used in a method chain. (@rrosenblum)Style/RedundantReturn to trigger when begin-end, rescue, and ensure blocks present. (@asherkach)Rails/InverseOf accept inverse_of: nil to opt-out. (@wata727)Rails/LexicallyScopedActionFilter. (@wata727)Rails/FilePath when using Rails.root.join in string interpolation of argument. (@koic)Rails/Presence when using with elsif. (@wata727)Layout/Tab. (@pocke)Style/FormatStringToken with unrelated format call. (@pocke)Rails/CreateTableWithTimestamps false positive when using to_proc syntax. (@wata727)Lint/Void to detect Kernel#tap as method that ignores the block's value. (@untitaker)Style/RedundantException auto-correction does not keep parenthesization. (@dpostorivo)RuboCop::AST::Node#updated. (@wata727)Style/SafeNavigation. (@jonas054)Performance::RegexpMatch when using MatchData before guard clause. (@koic)Style/EmptyElse auto-correct for nested if and case statements. (@asherkach)end alignment for variable assignment with line break after = in Layout/EndAlignment. (@jonas054)Style/ColonMethodCall when using Java package namespace. (@koic)Style/RedundantSelf with pseudo variables. (@pocke)Layout/BlockEndNewline when there is top level code outside of a class. (@rrosenblum)Lint/NumberConversion to use base 10 with Integer. (@rrosenblum)Style/EachWithObject auto-correction leaves an empty line. (@flyerhzm)Layout/EmptyLinesAroundAccessModifier false-negative when next string after access modifier started with end. (@unkmas)Performance/HashEachMethods cop as it no longer provides a performance benefit. (@urbanautomaton)Style/TrailingCommaInLiteral in favor of two new cops. (@garettarrowood)Lint/UnneededDisable to Lint/UnneededCopDisableDirective. (@garettarrowood)*.gemfile to Bundler cop target. (@sue445)Style/StringHashKeys to accepts environment variables. (@pocke)ActiveSupport::TimeZone#strftime method from defined dangerous methods of Rails/TimeZone cop. (@koic)Lint/EndAlignment, Lint/DefEndAlignment, Lint/BlockAlignment, and Lint/ConditionPosition to the Layout namespace. (@bquorning)Formatter::JSONFormatter from relative path to smart path. (@koic)Style/SafeNavigation will now register an offense for methods that nil responds to. (@rrosenblum).git/ by default. (@pocke)Style/SafeNavigation to no longer register an offense for method chains exceeding 2 methods. (@rrosenblum)Lint/SafeNavigationChain. (@rrosenblum)Lint/SafeNavigationChain to highlight the entire method chain beyond the safe navigation portion. (@rrosenblum)Layout/AlignHash when using a hash including only a keyword splat. (@wata727)Style/FormatStringToken to allow regexp token. (@pocke)Layout/EmptyLinesAroundArguments operating on blocks. (@garettarrowood)Rails/HasManyOrHasOneDependent when using class_name option. (@koic)Style/EvalWithLocation reporting bad line offset. (@pocke)Metrics/LineLength:Max for --auto-gen-config. (@jonas054)Rails/RedundantReceiverInWithOptions when including another receiver in with_options. (@wata727)Style/CommentedKeyword. (@garettarrowood)Style/MixinUsage when using inside class or module. (@koic)Layout/SpaceInsideReferenceBrackets and Layout/SpaceInsideArrayLiteralBrackets configuration conflicts. (@garettarrowood)Style/AutoResourceCleanup shouldn't flag File.open(...).close. (@dpostorivo)loaded_path in warning. (@chrishulton)Rails/HasManyOrHasOneDependent when using a option of has_many or has_one association. (@koic)Rails/Presence when the else block is multiline. (@wata727)Rails/InverseOf when including through or polymorphic options. (@wata727)--auto-gen-config might fail on invalid YAML. (@bquorning)Style/HashSyntax from stripping quotes off of symbols during auto-correction for ruby22+. (@garettarrowood)Layout/RescueEnsureAlignment in Ruby 2.5. (@pocke)Rails/InverseOf when using with_options. (@wata727)Style/BracesAroundHashParameters auto-correct. (@flyerhzm).ruby-version in parent directories. (@ybiquitous)Style/ExtendSelf cop. (@pocke)Layout/SpaceBeforeBlockBraces's EnforcedStyleForEmptyBraces from no_space to space. (@garettarrowood)Corrector classes and move all autocorrect methods out of mixin Modules. (@garettarrowood)Lint/NumberConversion cop. (@albertpaulp)TargetRubyVersion 2.5. (@walf443)Layout/ClassStructure cop that checks whether definitions in a class are in the configured order. This cop is disabled by default. (@jonatas)Rails/InverseOf checks for association arguments that require setting the inverse_of option manually. (@bdewater)Layout/SpaceInsideReferenceBrackets cop. (@garettarrowood)Layout/SpaceInsideArrayLiteralBrackets cop. (@garettarrowood)Style/TrailingBodyOnMethodDefinition cop. (@garettarrowood)Style/TrailingMethodEndStatement cop. (@garettarrowood)Style/StringHashKeys cop. (@donjar)Style/RandomWithOffset cop. (@donjar)Lint/ShadowedArgument cop and remove argument shadowing detection from Lint/UnusedBlockArgument and Lint/UnusedMethodArgument. (@akhramov)Lint/MissingCopEnableDirective cop. (@tdeo)Rails/EnvironmentComparison cop. (@tdeo)AllowedChars option to Style/AsciiComments cop. (@hedgesky)Style/EmptyBlockParameter and Style/EmptyLambdaParameter cops. (@pocke)Gemspec/RequiredRubyVersion cop. (@koic)Gemspec/RedundantAssignment cop. (@koic)unannotated option to Style/FormatStringToken cop. (@drenmi)Rails/CreateTableWithTimestamps cop. (@wata727)Style/ColonMethodDefinition cop. (@rrosenblum)Style/ExtendSelf cop. (@drenmi)Rails/RedundantReceiverInWithOptions cop. (@koic)Rails/LexicallyScopedActionFilter cop. (@wata727)Style/EvalWithLocation cop. (@pocke)Rails/Presence cop. (@wata727)Layout/EmptyLinesAroundArguments. (@garettarrowood)Style/ConstantName with constant names using non-ASCII capital letters with accents. (@timrogers)Layout/BlockEndNewline cop from introducing trailing whitespaces. (@bgeuken)Performance/HashEachMethods when unused argument(s) exists in other blocks. (@pocke)Performance/HashEachMethods. (@pocke)...::DateTime. (@dpostorivo)Lint/UnneededDisable, which was returning offenses even after being disabled in a comment. (@tdeo)EnforcedStyleForEmptyBraces for Layout/SpaceBeforeBlockBraces cop. (@drenmi)Rails/HasManyOrHasOneDependent aware of multiple associations in with_options. (@koic)Layout/MultilineOperationIndentation when an operation spans multiple lines and contains a ternary expression. (@rrosenblum)Style/MixinUsage cop. (@koic)Style/EmptyElse auto-correction removes comments from branches. (@dpostorivo)Style/UnneededPercentQ from breaking on strings that are concatenated with backslash. (@pocke)Style/PercentLiteralDelimiters incorrectly automatically modifies escaped percent literal delimiter. (@koic)Naming/ConstantName false offense on assigning to a nonoffensive assignment. (@garettarrowood)Style/HashSyntax cop when hash is used as unspaced argument. (@drenmi)Style/BracesAroundHashParameters auto-correction. (@garettarrowood)Style/MixinUsage when include call is a method argument. (@koic)Lint/UnneededSplatExpansion, when Array.new resides in an array literal. (@akhramov)Style/SafeNavigation when safe guarding arithmetic operation or assignment. (@tiagotex)Style/MinMax from breaking on implicit receivers. (@drenmi)Style/SafeNavigation when safe guarding comparisons. (@tiagotex)Style/RedundantParentheses cop when unspaced ternary is present. (@tiagotex)Naming/ConstantName cop when using frozen object assignment. (@koic)Style/SafeNavigation when the right hand side is negated. (@rrosenblum)Bundler/OrderedGems when gems are references from variables (ignores them in the sorting). (@tdeo)Metrics/ParameterLists. (@reitermarkus)Style/StderrPuts. (@jaredbeck)Lint/RedundantWithIndex cop aware of offset argument. (@koic)Metrics/LineLength: Max when generating .rubocop_todo.yml. (@jonas054)SupportedStyles from "Configuration parameters" in .rubocop_todo.yml. (@pocke)Lint/RescueWithoutErrorClass has been replaced by Style/RescueStandardError. (@rrosenblum)Layout/SpaceInsideBrackets in favor of two new configurable cops. (@garettarrowood)define_method. (@pocke)Layout/IndentHeredoc aware of line length. (@pocke)--show-cops option aware of --force-default-config. (@pocke)Lint/MissingCopEnableDirective cop. (@tdeo)Lint/Syntax cop with the same settings as the default. (@tdeo)Rails/UnknownEnv cop. (@pocke)Lint/UnneededRequireStatement cop. (@koic)Style/StderrPuts cop. (@koic)Lint/RedundantWithObject cop. (@koic)Style/CommentedKeyword cop. (@donjar)IndentationWidth configuration for Layout/Tab cop. (@rrosenblum)Lint/RegexpAsCondition cop. (@pocke)MethodDefinitionMacros option to Naming/PredicateName cop. (@koic)Gemspec/OrderedDependencies cop. (@sue445)Style/MixinUsage cop. (@koic)Style/DateTime cop. (@dpostorivo)Lint/Void check for nonmutating methods as well. (@donjar)Rails/Date Correct false positive on #to_time for strings ending in UTC-"Z". (@erikdstock)Style/SafeNavigation correctly exclude methods called without dot. (@drenmi)Lint/RescueWithoutErrorClass aware of modifier form rescue. (@drenmi)Style/SafeNavigation ignore negated continuations. (@drenmi)Performance/HashEachMethods from registering an offense when #each follows #to_a. (@drenmi)Rails/HasManyOrHasOneDependent cop from registering offense if :through option was specified. (@smakagon)return is in top scope. (@frodsan)Rails/Blank and Rails/Present from breaking when there is no explicit receiver. (@rrosenblum)Rails/Blank from breaking on send with an argument. (@pocke)Naming/HeredocDelimiterNaming and Naming/HeredocDelimiterCase aware of more delimiter patterns. (@drenmi)Lint/UnusedMethodArgument and Lint/UnusedBlockArgument aware of overriding assignments. (@akhramov)Lint/BooleanSymbol from truncating symbol's value in the message when offense is located in the new syntax hash. (@akhramov)Rails/HasManyOrHasOneDependent cop incorrectly flags with_options blocks. (@koic)Rails/OutputSafety aware of safe navigation operator. (@drenmi)Lint/ShadowedException cop aware of same system error code. (@koic)Style/TrailingUnderscoreVariable work for nested assignments. (@donjar)Style/StringLiterals cop not registering an offense on single quoted strings containing an escaped single quote when configured to use double quotes. (@promisedlandt)Lint/UnusedMethodArgument respects IgnoreEmptyMethods setting by ignoring unused method arguments for singleton methods. (@jmks)Lint/InvalidCharacterLiteral cop has been removed since it was never being actually triggered. (@deivid-rodriguez)Severity and other common parameters can be configured on department level. (@jonas054)Lint/LiteralInCondition cop aware of ! and not. (@pocke)Lint/LiteralInCondition to Lint/LiteralAsCondition. (@pocke)EnforcedStyleForEmptyBraces parameter to Layout/SpaceBeforeBlockBraces cop. (@palkan)Style/RedundantConditional checks for conditionals that return true/false. (@petehamilton)TapFormatter. (@cyberdelia)Style/HeredocDelimiters cop(Note: This cop was renamed to Naming/HeredocDelimiterNaming). (@drenmi)Lint/ReturnInVoidContext checks for the use of a return with a value in a context where it will be ignored. (@harold-s)Lint/ScriptPermission. (@rrosenblum)Style/YodaCondition to support checking all comparison operators or equality operators only. (@smakagon)Lint/BooleanSymbol cop. (@droptheplot)Rails/PluralizationGrammar use singular methods for -1 / -1.0. (@promisedlandt)Rails/HasManyOrHasOneDependent cop. (@oboxodo)Style/Dir cop. (@drenmi)Style/HeredocDelimiterCase cop(Note: This cop is renamed to Naming/HeredocDelimiterCase). (@drenmi)Lint/RescueWithoutErrorClass cop. (@drenmi)Style/TrailingUnderscoreVariable. (@smakagon)Performance/UnfreezeString cop. (@pocke)Whitelist configuration option to Style/NestedParenthesizedCalls cop. (@drenmi)Style/OrAssignment cop. (@donjar)rake new_cop create parent directories if they do not already exist. (@highb)Performance/HashEachMethod inspect send nodes with any receiver. (@gohdaniel15)Style/ReturnNil cop. (@donjar)define_method. (@jekuta)Lint/UriEscapeUnescape cop. (@koic)Performance/UriDefaultParser cop. (@koic)Lint/UriRegexp cop. (@koic)Style/MinMax cop. (@drenmi)Bundler/InsecureProtocolSource cop. (@koic)Lint/RedundantWithIndex cop. (@koic)Lint/InterpolationCheck cop. (@GauthamGoli)Lint/NestedPercentLiteral cop. (@asherkach)Style/RedundantConditional cop work with elsif. (@akhramov)Style/ConditionalAssignment auto-correction to work with unbracketed arrays. (@akhramov)<=> a comparison method. (@iGEL)Lint/FormatParameterMismatch false positive if format string includes %%5B (CGI encoded left bracket). (@barthez)Style/LambdaCall to auto-correct obj.call to obj.. (@iGEL)Style/YodaCondition from breaking not LITERAL. (@pocke)Style/Alias for non-literal arguments. (@drenmi)Style/AndOr cop aware of comparison methods. (@drenmi)Lint/Void with initialize and setter methods. (@pocke)Style/ConditionalAssignment when the assignment line is the longest line, and it does not exceed the max line length. (@rrosenblum)Style/EmptyElse for nested if. (@pocke)Lint/UnreachableCode aware of if and case. (@pocke)Performance/RegexpMatch for named captures. (@pocke)rubocop:disable all in Lint/UnneededDisable. (@meganemura)Style/VariableName aware of optarg, kwarg and other arguments. (@pocke)Style/WordArray and Style/SymbolArray from registering offenses where percent arrays don't work. (@drenmi)Layout/EmptyLineBetweenDefs from removing too many lines. (@drenmi)Style/NumericPredicate ignore numeric comparison of global variables. (@drenmi)Layout/Multiline*BraceLayout. (@jonas054)Style/SafeNavigation does not register an offense when there are chained method calls. (@rrosenblum)Rails/Delegate. (@cgriego)Lint/Void cop. (@pocke)Performance/RegexpMatch cop for =~ is in a class method. (@pocke)Lint/FormatParameterMismatch for format with "asterisk" (*) width and precision. (@smakagon)Lint/DefEndAlignment aware of multiple modifiers. (@drenmi)Layout/IndentHeredoc cop. (@pocke)Lint/Debugger aware of Kernel and cbase. (@pocke)Style/InverseMethods to not register a separate offense for an inverse method nested inside of the block of an inverse method offense. (@rrosenblum)Rails/SaveBang when save/update_attribute is used with a case statement. (@theRealNG)rake new_cop problem that doesn't add require line. (@koic)RaiseArgs auto-correction issue for raise with 3 arguments. (@smakagon)Lint/AssignmentInCondition. (@brandonweiss)node_modules to default excludes. (@iainbeeston)Style/Encoding cop enabled by default. (@deivid-rodriguez)Rails/Delegate for enforcing the prefixed method name case. (@klesse413)Lint/Void cop aware of Enumerable#each and for. (@pocke)Lint/DuplicateMethods aware of alias and alias_method. (@pocke)Performance/Caller cop. (@pocke)Lint/DuplicateMethods aware of attr_* methods. (@pocke)RuboCop::CLI#run as a public API. (@yujinakayama)Performance/Caller aware of caller_locations. (@pocke)Style/HeredocDelimiters to Style/HeredocDelimiterNaming. (@drenmi)Style/RedundantReturn cop. (@gohdaniel15)Naming department. (@drenmi)Style/RedundantSelf aware of arguments of a block. (@Envek)Performance/TimesMap by default. (@Envek)Style/YodaCondition. (@bbatsov)Style/YodaCondition. (@bbatsov)Style/YodaCondition. (@bbatsov)Style/Next when the end is misaligned. (@rrosenblum)Performance/RegexpMatch from blowing up on match without arguments. (@pocke)for loops in Style/ConditionalAssignment. (@bbatsov)AllCops: DisabledByDefault: true and Rails: Enabled: true. (@jonas054)Style/MultipleComparison. (@timrogers)Style/EmptyMethod honours indentation when auto-correcting. (@drenmi)Style/WordArray from breaking on strings that aren't valid UTF-8. (@pocke)Layout/SpaceAroundBlockParameters from breaking on lambda. (@pocke)--parallel option for running RuboCop in multiple processes or threads. (@jonas054)Style/MixinGrouping. (@rrosenblum)Rails/ApplicationJob and Rails/ApplicationRecord cops. (@tjwp)Performance/Caller cop. (@alpaca-tc)Array#sort by Performance/CompareWithBlock. (@pocke)Style/FormatStringToken cop. (@backus)Lint/ScriptPermission cop. (@yhirano55)Style/YodaCondition cop. (@smakagon)Cop.autocorrect_incompatible_with for specifying other cops that should not auto-correct together. (@backus)Style/FormatString. (@hoshinotsuyoshi)Style/MultipleComparison cop. (@dabroz)Lint/RescueType cop. (@rrosenblum)--ignore-parent-exclusion flag to ignore AllCops/Exclude inheritance. (@nelsonjr)MinSize configuration to Style/SymbolArray, consistent with the same configuration in Style/WordArray. (@scottmatthewman)Layout. (@jonas054)Rails/OutputSafety to disallow wrapping raw or html_safe with safe_join. (@klesse413)rubocop_cache in safer directories. (@jonas054)Lint/DuplicateMethods. (@pocke).jb file by default. (@pocke)Style/SpaceBeforeFirstArg cop. (@cjlarose)Lint/AmbiguousBlockAssociation cop for lambdas. (@smakagon)Capfile to the list of known Ruby filenames. (@bbatsov)||= in Rails/RelativeDateConstant. (@bbatsov)Rails/Blank and Rails/Present from breaking when there is no explicit receiver. (@rrosenblum)Rails/RelativeDateConstant. (@bbatsov)Style/EmptyCaseCondition auto-correct bug - when first when branch includes comma-delimited alternatives. (@ilansh)Style/MethodCallWithArgsParentheses from blowing up on yield. (@drenmi)DisabledByDefault is true. (@jonas054)Rails/SaveBang from blowing up when using the assigned variable in a hash. (@drenmi)Security/Eval cop for multiline string literal. (@pocke)Security/Eval cop for Binding#eval. (@pocke)Layout/SpaceInsidePercentLiteralDelimiters from registering offenses on execute-strings. (@drenmi)Style/MethodName from complaining about unary operator definitions. (@drenmi)Performance/RedundantMerge from blowing up on double splat arguments. (@drenmi)Style/AndOr when Enumerable accessors ([]) are used. (@rrosenblum)Style/InverseMethods from registering an offense for methods that are double negated. (@rrosenblum)Rails/SkipsModelValidations from registering an offense for FileUtils.touch. (@rrosenblum)Style/IndentationConsistency cop. (@pocke)-n option. (@sadovnik)Style/PercentLiteralDelimiters default configuration to match Style Guide update. (@drenmi)Lint/AmbiguousBlockAssociation cop. (@smakagon)Rails/Blank from breaking when RHS of or is a naked falsiness check. (@drenmi)Lint/AmbiguousBlockAssociation aware of lambdas passed as arguments. (@drenmi)Rails/Blank from breaking when LHS of or is a naked falsiness check. (@rrosenblum)Style/MixinGrouping cop. (@drenmi)Lint/NestedMethodDefinition aware of #*_exec class of methods. (@drenmi)Style/RedundantSelf cop with parallel assignment. (@drenmi)Style/SymbolArray and Style/WordArray cop. (@pocke)Lint/NestedMethodDefinition aware of class shovel scope. (@drenmi)Lint/AmbiguousBlockAssociation aware of operator methods. (@drenmi)Style/MethodCallWithArgsParentheses not require parens on setter methods. (@drenmi)--help output that --stdin takes a file name argument. (@jonas054)Rails/FilePath cop with non string argument. (@soutaro)Style/TernaryParentheses unsafe auto-correct detector aware of literals and constants. (@drenmi)Lint/AmbiguousBlockAssociation cop. (@smakagon)Rails/RelativeDate for lambdas and procs. (@smakagon)TargetRailsVersion configuration parameter can be used to specify which version of Rails the inspected code is intended to run on. (@maxbeizer)prefix and postfix styles to Style/NegatedIf. (@brandonweiss)NumberOfEmptyLines for Style/EmptyLineBetweenDefs. (@dorian)Strict for Style/NumericLiteral to make the change to this cop in 0.47.0 configurable. (@iGEL)AllCops/EnabledByDefault option. (@betesh)IncludeActiveSupportAliases, to Performance/DoubleStartEndWith. This configuration will check for ActiveSupport's starts_with? and ends_with?. (@rrosenblum)Style/EmptyLineAfterMagicComment cop. (@backus)Style/EndOfLine configurable with lf, crlf, and native (default) styles. (@jonas054)Style/MixinGrouping cop. (@drenmi)Rails/RelativeDateConstant cop. (@sinsoku)Style/EmptyLinesAroundBeginBody cop. (@pocke)Style/EmptyLinesAroundExceptionHandlingKeywords cop. (@pocke)Style/MultilineMemoization cop. (@pocke)Lint/EmptyEnsure cop. (@pocke)Style/IndentHeredoc cop. (@pocke)Lint/AmbiguousBlockAssociation cop. (@smakagon)Style/InverseMethods cop. (@rrosenblum)default key in the Style/PercentLiteralDelimiters cop config to set all preferred delimiters. (@kddeisz)IgnoreMacros option to Style/MethodCallWithArgsParentheses. (@drenmi)Rails/ActiveSupportAliases cop. (@tdeo)Rails/Blank cop. (@rrosenblum)Rails/Present cop. (@rrosenblum)Bundler/OrderedGems cop. (@konto-andrzeja)update_attributes. (@andriymosin)Style/EmptyLineBetweenDefs doesn't allow more than one empty line between method definitions by default (see NumberOfEmptyLines). (@dorian)foo[:bar] as not complex in Style/TernaryParentheses cop with require_parentheses_when_complex style. (@onk)Lint/SafeNavigationChain cop. (@pocke)Style/RaiseArgs cop. (@mikegee)Performance/DoubleStartEndWith. (@rrosenblum)Rails/Date cop to register an offence for a string without timezone. (@sinsoku)new_cop.rake suggested path. (@dabroz)Metrics/ParameterLists cop. (@pocke)Marshal.load if argument is a Marshal.dump in Security/MarshalLoad cop. (@droptheplot)Style/SymbolArray cop to enable by default. (@pocke)Style/MultilineMethodCallIndentation indented_relative_to_receiver to indent relative to the receiver and not relative to the caller. (@jfelchner)IndentationWidth by regex. (@jfelchner)Rails/SkipsModelValidations for methods that don't accept arguments. (@dorian)Bundler/OrderedGems. (@mikegee)Lint/NonLocalExitFromIterator aware of method definitions. (@drenmi)MagicComment. (@mikegee)Style/MutableConstant. (@mikegee)Performance/RegexpMatch with English module. (@pocke)Errno::ENOENT during cache cleanup from File.mtime too. (@mikegee)Style/SpaceInsideHashLiteralBraces doesn't add and offence when checking an hash where a value is a left brace string (e.g. { k: '{' }). (@nodo)Style/WhileUntilModifier from breaking on a multiline modifier. (@drenmi)Style/WordArray's WordRegex configuration value to be an instance of String. (@mikegee)Style/RedundantSelf when assigning to same local variable. (@bankair)find_zone and find_zone! methods in Rails/TimeZone. (@attilahorvath)Lint/ShadowedException when an exception is shadowed and there is an implicit begin. (@rrosenblum)Include/Exclude paths in all files beginning with .rubocop be relative to the configuration file's directory and not to the current directory. (@jonas054)Style/EmptyLiteral cop. (@ota42y)Style/StringLiterals, Style/UnneededCapitalW and Style/UnneededPercentQ cops. (@pocke)Style/SelfAssignment cop. (@pocke)Style/BracesAroundHashParameters cop. (@musialik)Style/TernaryParentheses cop. (@musialik)Security/JSONLoad, Security/MarshalLoad and Security/YAMLLoad cops patterns not matching ::Const. (@musialik)# rubocop:disable all and # rubocop:disable SomeCop. (@jonas054)Style/SymbolArray cop. (@pocke)Style/CaseIndentation cop from registering offenses on single-line case statements. (@drenmi)Style/IdenticalConditionalBranches from registering offenses when a case statement has an empty when. (@dpostorivo)UselessAssignment cop may not properly detect useless assignments when there's only a single conditional expression in the top level scope. (@yujinakayama)UselessAssignment cop with nested conditionals. (@yujinakayama)Performance/RegexpMatch cop with module definition. (@pocke)Style/AlignHash from breaking on a keyword splat when using enforced table style. (@drenmi)Rails/EnumUniqueness from breaking on a non-literal hash value. (@drenmi)NodePattern works for hyphenated node types. (@alexdowad)Style/NegatedIf from breaking on negated ternary. (@drenmi)Lint/SafeNavigationChain cop with try method. (@pocke)Rails/FilePath cop. (@iguchi1124)Security/YAMLLoad cop. (@cyberdelia)Security/MarshalLoad cop. (@cyberdelia)Bundler/OrderedGems cop. (@pocke)Style/FrozenStringLiteralComment now supports the style never that will remove the frozen_string_literal comment. (@rrosenblum)Lint/MultipleCompare cop. (@pocke)Metrics/BlockLength. (@NobodysNightmare)Lint/SafeNavigationChain cop. (@pocke)CountBlocks boolean option to Metrics/BlockNesting. It allows blocks to be counted towards the nesting limit. (@georgyangelov)Style/ConditionalAssignment to toggle offenses for ternary expressions. (@rrosenblum)Performance/RegexpMatch cop. (@pocke)Rails/SkipsModelValidations cop. (@rahulcs)Style/MethodCallWithArgsParentheses cop. (@dominh)MethodCallParentheses to MethodCallWithoutArgsParentheses. (@dominh)Rails/ReversibleMigration cop. (@sue445)String#% with hash literal. (@backus)Lint/UselessAccessModifier. (@pat)Lint/Eval to Security/Eval. (@cyberdelia)Style/SingleLineBlockParams by default. (@tejasbubane)AlignWith, IndentWhenRelativeTo and EnforcedMode configurations are renamed. (@pocke)add_reference method by Rails/NotNullColumn cop. (@pocke)Style/RedundantFreeze message from Freezing immutable objects is pointless. to Do not freeze immutable objects, as freezing them has no effect.. (@lucasuyezu)Bundler/OrderedGems to mention Alphabetize Gems. (@tejasbubane)Lint cops documentation. (@enriikke)Style/EmptyMethod cop aware of class methods. (@drenmi)defined? and self by Lint/Void cop. (@pocke)Style/BlockDelimiters when using any style. (@twe4ked)Rails/EnumUniqueness cop. (@pocke)Style/ConditionalAssignment cop with masgn. (@pocke)Style/RedundantParentheses Don't flag raised to a power negative numeric literals, since removing the parentheses would change the meaning of the expressions. (@amogil)Style/ConditionalAssignment when the assignment spans multiple lines. (@rrosenblum)Style/HashSyntax cop with an empty hash. (@pocke)Rails/HttpPositionalArguments when methods are defined with them. (@kevindew)Style/ConditionalAssignment cop with mass assign method. (@pocke)Style/NumericLiterals. (@kamaradclimber)Style/Next when block has nested conditionals. (@drenmi)Style/Documentation and Style/DocumentationMethod from mistaking RuboCop directives for class documentation. (@drenmi)Style/IdenticalConditionalBranches cop when branches have same line at leading. (@pocke)Rails/HttpPositionalArguments where offense would go undetected if one of the request parameter names matched one of the special keyword arguments. (@deivid-rodriguez)Rails/HttpPositionalArguments where offense would go undetected if the :format keyword was used with other non-special keywords. (@deivid-rodriguez)Lint/FormatParameterMismatch for splatted last argument. (@zverok)RedundantParentheses cop with multiple expression. (@pocke)Rails/HttpPositionalArguments. (@pocke)Lint/FormatParameterMismatch from breaking when #% is passed an empty array. (@drenmi)FrozenStringLiteralComment. (@backus)Style/EachWithObject. (@pocke)Bundler/DuplicatedGem cop. (@jmks)empty_lines_special to Style/EmptyLinesAroundClassBody and Style/EmptyLinesAroundModuleBody. (@legendetm)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)DisabledByDefault in parent configs. (@aroben)Rails/EnumUniqueness checks for duplicate values defined in enum config. (@olliebennett)Rails/EnumUniqueness checks for duplicate values defined in enum config hash. (@olliebennett)require_parentheses_when_complex style to Style/TernaryParentheses cop. (@swcraig)Bundler/OrderedGems cop. (@tdeo)IgnoredPatterns to Metrics/LineLength. (@jonas054)Performance/FlatMap now includes any parameters that are passed to flatten. (@rrosenblum)Style/SpecialGlobalVars messages with a reminder to require 'English'. (@ivanovaleksey)binding.irb call by Lint/Debugger cop. (@pocke)min and max call by Performance/CompareWithBlock cop. (@pocke)Lint/UnneededSplatExpansion when the splat expansion is inside of another array. (@rrosenblum)Style/VariableNumber on variable names ending with an underscore. (@bquorning)Style/TernaryParentheses cop claims to correct uncorrected offenses. (@Ana06)--auto-gen-config behavior for Style/VariableNumber. (@jonas054)format as an acceptable keyword argument for Rails/HttpPositionalArguments. (@aesthetikx)Style/NumericPredicate, don't report x != 0 or x.nonzero? as the expressions have different values. (@jonas054)Style/SpaceInsideBlockBraces. (@rrosenblum)Lint/NonLocalExitFromIterator does not warn about return in a block which is passed to Object#define_singleton_method. (@AlexWayfer)Lint/EmptyInterpolation. (@pocke)PercentLiteralDelimiters enforce delimiters around %I() too. (@bronson)Lint/EmptyWhen cop. (@drenmi)--force-default-config option. (@jawshooah)MultilineIfModifier cop to avoid usage of if/unless-modifiers on multiline statements. (@tessi)Style/SpaceInLambdaLiteral cop to check for spaces in lambda literals. (@swcraig)Lint/EmptyExpression cop. (@drenmi)Style/RedundantSelf cop to not register an offence for self.(). (@iGEL)Rails/TimeZone only analyze functions which have "Time" in the receiver. (@b-t-g)Style/RedundantReturn cop for empty if body. (@pocke)raw and html_safe methods in Rails/OutputSafety. (@lumeet)when blocks. (@albus522)Metrics/MethodLength and Metrics/BlockLength. (@meganemura)begin..end block in Style/MultilineMethodCallIndentation. (@jonas054)Rails/HttpPositionalArguments. (@eitoball)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)Style/VariableNumber registering an offense for variables with double digit numbers. (@rrosenblum)rails style indentation also inside blocks in Style/IndentationWidth. (@jonas054)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. Default args changed to acc and elem. (@jessieay)Style/RedundantReturn. (@tiagocasanovapt)Style/ConditionalAssignment. (@rrosenblum)require. (@bbatsov)empty_lines_except_namespace to Style/EmptyLinesAroundClassBody and Style/EmptyLinesAroundModuleBody. (@legendetm)Rails/HttpPositionalArguments cop to check your Rails 5 test code for existence of positional args usage. (@logicminds)ConvertCodeThatCanStartToReturnNil, to Style/SafeNavigation to check for code that could start returning nil if safe navigation is used. (@rrosenblum)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)Metric/BlockLength cop to ensure blocks don't get too long. (@savef)Style/PreferredHashMethods with either short or verbose style method names. (@abrom)Rails/DynamicFindBy cop. (@pocke)IgnoreCopDirectives, to Metrics/LineLength to stop cop directives (# rubocop:disable Metrics/AbcSize) from being counted when considering line length. (@jmks)Rails/DelegateAllowBlank cop. (@connorjacobsen)Style/MultilineMemoization cop. (@drenmi)Style/ExtraSpacing cop register an offense for extra spaces present in single-line hash literals. (@tcdowney)Style/TernaryParentheses for a ternary with ranges. (@dreyks)Lint/AssignmentInCondition false positive. (@savef)Style/VariableNumber cop not register an offense when valid normal case variable names have an integer after the first _. (@b-t-g)Style/VariableNumber cop not register an offense when valid normal case variable names have an integer in the middle. (@b-t-g)Rails/SaveBang cop not register an offense when return value of a non-bang method is returned by the parent method. (@coorasse)Style/GuardClause to register offense for instance and singleton methods. (@tejasbubane)Style/StringLiterals. (@deivid-rodriguez)Lint/UnusedBlockArgument doesn't make recommendations that would change arity for methods defined using #define_method. (@drenmi)Performance/RedundantMerge when inspecting a #merge! with implicit receiver. (@drenmi)when in Performance/CaseWhenSplat. (@jonas054)self.a, self.b = b, a in Style/ParallelAssignment. (@jonas054)unless x.nil? in Style/NonNilCheck if IncludeSemanticChanges is true. (@jonas054)Style/EmptyElse. (@lumeet)\s) in Style/UnneededCapitalW. (@rrosenblum)Style/RaiseArgs not allowing compact raise with splatted args. (@savef)Metrics/AbcSize. (@savef)Style/RedundantParentheses for indexing with literals. (@thegedge)Performance/CaseWhenSplat when trying to rearrange splat expanded variables to the end of a when condition. (@rrosenblum)Lint/UnneededSplatExpansion for array in method parameters. (@tejasbubane)Style/SafeNavigation. Fix auto-correct of multiline if expressions, and do not register an offense for scenarios using || and ternary expression. (@rrosenblum)Style/EmptyLinesAroundAccessModifier. (@bquorning)Security/JSONLoad by default. (@savef)Style/RedundantReturn looks for redundant return inside conditional branches. (@lumeet)Style/DocumentationMethod cop. (@sooyang)RequireForNonPublicMethods configuration option to Style/DocumentationMethod cop. (@drenmi)Rails/SafeNavigation cop to convert try! to &.. (@rrosenblum)Rails/NotNullColumn cop. (@pocke)Style/VariableNumber cop. (@sooyang)no_mixed_keys to Style/HashSyntax to only check for hashes with mixed keys. (@daviddavis)persisted? method call when using a create method in Rails/SaveBang. (@QuinnHarris)Style/SafeNavigation cop to convert method calls safeguarded by a non nil check for the object to &.. (@rrosenblum)Performance/SortWithBlock cop to use sort_by(&:foo) instead of sort { |a, b| a.foo <=> b.foo }. (@koic)UnifiedInteger cop. (@pocke)Style/RedundantSelf cop. (@bankair)Style/AndOr cop. (@mikezter)Style/Lambda cop. (@metcalf)Performance/RedundantMatch cop. (@annaswims)Style/TernaryParentheses cop when used together with Style/RedundantParentheses. (@drenmi)Style/GuardClause cop. (@drenmi)Style/MutableConstant cop aware of splat assignments. (@drenmi)Style/Next cop. (@pocke)Style/MethodMissing cop aware of class scope. (@drenmi)Lint/ShadowedException cop if last rescue does not have parameter. (@soutaro)Style/TrailingUnderscoreVariable cop. (@drenmi)Lint/ShadowedException would register an offense when rescuing different numbers of custom exceptions in multiple rescue groups. (@rrosenblum)VariableForce understand an empty RegExp literal as LHS to =~. (@drenmi)inherit_from additions when not using Namespaces in the configs. (@nicklamuro)Lint/PercentStringArray cop. (@pocke)SpaceInsideBlockBraces and SpaceBeforeBlockBraces not depend on BlockDelimiters configuration. (@jonas054)Lint/ShadowedException cop for higher number of rescue groups. (@groddeck)Style/MultilineMethodCallBraceLayout. (@pocke)Rails/SaveBang. (@QuinnHarris)Style/EndOfLine works on Windows. (@jonas054)Style/TernaryParentheses cop from making unsafe corrections. (@drenmi)Style/InlineComment cop. (@drenmi)Rails/NotNullColumn. (@pocke)Style/NumericPredicate cop. (@drenmi)Lint/UselessArraySplat to Lint/UnneededSplatExpansion, and add functionality to check for unnecessary expansion of other literals. (@rrosenblum)Performance/CaseWhenSplat. Lint/UnneededSplatExpansion now handles this behavior. (@rrosenblum)Lint/InheritException restricts inheriting from standard library subclasses of Exception. (@metcalf)#\ in Style/LeadingCommentSpace. config.ru files consider such lines as options. (@scottohara)Performance/PushSplat as it can produce code that is slower or even cause failure. (@jonas054)Style/EachWithObject. (@owst)Style/TernaryParentheses cop. (@drenmi)UselessAccessModifier so it can be made aware of ActiveSupport's concerning and class_methods methods. (@maxjacobson)Rails/SaveBang cop. (@QuinnHarris)Style/NumericPredicate cop. (@drenmi)Style/EachForSimpleLoop cop. (@drenmi)Style/ParallelAssignment cop. (@jonas054)Style/MethodCallParentheses cop. (@drenmi)Style/SingleLineBlockParams cop. (@owst)Style/OpMethod aware of the backtick method. (@drenmi)Lint/ShadowedException when rescuing an exception built into Ruby before a custom exception. (@rrosenblum)Style/EmptyLiteral no longer generates an offense for String.new when using frozen string literals. (@drenmi)Lint/NextWithoutAccumulator aware of nested enumeration. (@drenmi)Style/MethodMissing cop to check for the conditions in the style guide. (@drenmi)Style/Multiline...BraceLayout cops. (@jonas054)Exception before or along with any other exception in Lint/ShadowedException. (@rrosenblum).ruby-version. (@tjwp)TargetRubyVersion to .ruby-version. (@tjwp)rescue nil in Style/ShadowedException. (@rrosenblum)Style/ShadowedException to be more useful. Highlight just rescue area. (@rrosenblum)Style/MethodCallParentheses to work with multiple assignments. (@tejasbubane)Style/BlockDelimiters. (@tjwp)Lint/UnneededDisable can do auto-correction. (@jonas054)Lint/ShadowedException to block arbitrary code execution. (@pocke)Performance/RedundantBlockCall auto-correct. (@jonas054)Style/RaiseArgs when constructing exception without arguments. (@drenmi)Time.zone_default. (@Tei)%q()s containing escaped non-backslashes. (@owst)Style/AsciiComments cop. (@drenmi)Style/AsciiIdentifiers cop. (@drenmi).ruby-version to TargetRubyVersion. (@pclalv)IndentationWidth configuration parameter for Style/AlignParameters cop. (@alexdowad)Style/ImplicitRuntimeError cop which advises the use of an explicit exception class when raising an error. (@alexdowad)Style/EachForSimpleLoop cop which advises the use of Integer#times for simple loops which iterate a fixed number of times. (@alexdowad)compact style for Style/SpaceInsideLiteralHashBraces. (@alexdowad)Rails/Validation cop. (@neodelf)Rails/OutputSafety cop. (@josh)Style/ModuleFunction configurable with module_function and extend_self styles. (@tjwp)Rails/RequestReferrer cop. (@giannileggio)Style/EachForSimpleLoop cop. (@tejasbubane)Style/SpaceInsideArrayPercentLiteral cop. (@owst)Style/SpaceInsidePercentLiteralDelimiters cop. (@owst)Lint/PercentStringArray cop. (@owst)Lint/PercentSymbolArray cop. (@owst)Style/NumericLiteralPrefix cop. (@tejasbubane)indented_relative_to_receiver for Style/MultilineMethodCallIndentation. (@jonas054)Lint/ShadowedException checks for the order which exceptions are rescued to avoid rescuing a less specific exception before a more specific exception. (@rrosenblum)Lint/InheritException checks for error classes inheriting from Exception, and instead suggests RuntimeError or StandardError. (@drenmi)Performance/PushSplat cop. (@segiddins)Rails/Exit cop. (@sgringwe)Style/MethodMissing cop. (@haziqhafizuddin)Style/StringLiterals understands that a bare '#', not '#@variable' or '#{interpolation}', does not require double quotes. (@alexdowad)Style/ExtraSpacing does not attempt to align an equals sign in an argument list with one in an assignment statement. (@alexdowad)Style/MultilineMethodCallBraceLayout does not register offenses for single-line calls. (@alexdowad)Style/MutableConstant does not infinite-loop when correcting an array with no brackets. (@alexdowad)Lint/UnusedBlockArgument's IgnoreEmptyBlocks parameter from being removed from configuration. (@jfelchner)end when auto-correcting Style/EmptyElse. (@rrosenblum)Lint/UselessAccessModifier reporting useless access modifiers inside {Class,Module,Struct}.new blocks. (@owst)Rails/UniqBeforePluck to ignore uniq with block. (@tejasbubane)Style/SpaceAroundKeyword allows &. method calls after super and yield. (@segiddins)Style/ZeroLengthPredicate to ignore size and length variables. (@tejasbubane)NegatedIf and NegatedWhile to ignore double negations. (@natalzia-paperless)Style/FrozenStringLiteralComment works with file doesn't have any tokens. (@pocke)() in Style/RedundantParentheses. (@lumeet)Style/SpaceAfterNot reporting on the not keyword. (@NobodysNightmare)Style/Lambda fix whitespacing when auto-correcting unparenthesized arguments. (@palkan)Style/StringLiterals. (@jonas054)LineEndConcatenation and UnneededInterpolation make changes to the same string during auto-correct. (@jonas054)Style/BlockDelimiters ignore blocks in all method arguments. (@jonas054)Style/ParallelAssignment to use implicit begins when parallel assignment uses a rescue modifier and is the only thing in the method. (@rrosenblum)while/until and begin..end + while/until in Style/InfiniteLoop. (@jonas054)Style/EmptyElse registering wrong offenses and thus making RuboCop crash. (@deivid-rodriguez)Style/SpaceInsideBlockBraces reports offenses for multi-line blocks. (@owst)Style/StringLiterals to register offenses on non-ascii strings. (@deivid-rodriguez)Style/StringLiterals to register offenses on non-ascii strings. (@deivid-rodriguez)RedundantBlockCall to not report calls that pass block arguments, or where the block has been overridden. (@owst).rubocop_todo.yml if different styles are used. (@flexoid)Rails/UniqBeforePluck more conservative. (@tjwp)Style/HashSyntax configurable to not report hash rocket syntax for symbols ending with ? or ! when using ruby19 style. (@owst)Style/ClosingParenthesisIndentation follow Style/AlignParameters configuration for method calls. (@jonas054)Style/DeprecatedHashMethods to Style/PreferredHashMethods. (@tejasbubane)Performance/CaseWhenSplat can now identify multiple offenses in the same branch and offenses that do not occur as the first argument. (@rrosenblum)Style/NestedParenthesizedCalls cop can auto-correct. (@drenmi)Style/RaiseArgs cop can auto-correct. (@drenmi)Style/SpaceAfterColon now checks optional keyword arguments. (@owst).rubocop file and RUBOCOP_OPTS environment variable. (@bolshakov)Style/MultilineArrayBraceLayout enforced style is configurable and supports symmetrical and new_line options. (@panthomakos)Style/MultilineHashBraceLayout enforced style is configurable and supports symmetrical and new_line options. (@panthomakos)Style/MultilineMethodCallBraceLayout enforced style is configurable and supports symmetrical and new_line options. (@panthomakos)Style/MultilineMethodDefinitionBraceLayout enforced style is configurable and supports symmetrical and new_line options. (@panthomakos)Style/MultilineArrayBraceLayout enforced style supports same_line option. (@panthomakos)Style/MultilineHashBraceLayout enforced style supports same_line option. (@panthomakos)Style/MultilineMethodCallBraceLayout enforced style supports same_line option. (@panthomakos)Style/MultilineMethodDefinitionBraceLayout enforced style supports same_line option. (@panthomakos)Style/EmptyCaseCondition cop. (@owst, @rrosenblum)Lint/UselessArraySplat cop. (@owst)Style/Lambda enforced style supports literal option. (@drenmi)Style/Lambda enforced style supports lambda option. (@drenmi)Style/Encoding to enforce using no encoding comments. (@NobodysNightmare)Rails/UniqBeforePluck checks that uniq is used before pluck. (@tjwp)Style/ClassAndModuleChildren for nested classes with explicit superclass. (@jspanjers)Style/AlignParameters message was clarified for with_fixed_indentation style. (@dylanahsmith)UnusedBlockArgument for keyword arguments. (@volkert)) consistent with comment indentation before } or ]. (@jonas054)Style/SpaceAroundOperators, and not Style/SpaceAfterColon too). (@owst)merge! on a method on a variable inside each_with_object in Performance/RedundantMerge. (@lumeet, @rrosenblum)Style/SpaceAfterNot will now register an offense for a receiver that is wrapped in parentheses. (@rrosenblum)match without a receiver in Performance/EndWith. (@lumeet)match without a receiver in Performance/StartWith. (@lumeet)Lint/NestedMethodDefinition shouldn't flag methods defined on Structs. (@owst)Lint/UnneededDisable inspect files that are excluded for the cop. (@jonas054)Style/RedundantParentheses. (@lumeet)Lint/UselessAccessModifier detect conditionally defined methods and correctly handle dynamically defined methods and singleton class methods. (@owst)Style/Alias offenses for use of alias in instance_eval blocks, since object instances don't respond to alias_method. (@magni-)Style/Multiline*BraceLayout cops. (@panthomakos)Style/SymbolProc. (@rrosenblum)a + \ into a + \\ in Style/LineEndConcatenation. (@jonas054)RuntimeError.new(msg) in Style/RedundantException. (@jonas054)Style/SpaceAfterComma now uses Style/SpaceInsideHashLiteralBraces's setting. (@ptarjan)rubocop-todo.yml. (@ptarjan)define_method to the default list of IgnoredMethods of Style/SymbolProc. (@jastkand)Style/SpaceAfterNot highlights the entire expression instead of just the exclamation mark. (@rrosenblum)Style/MultilineArrayBraceLayout and Style/MultilineHashBraceLayout with the symmetrical style by default. (@panthomakos)Style/MultilineMethodCallBraceLayout and Style/MultilineMethodDefinitionBraceLayout with the symmetrical style by default. (@panthomakos)Style/PredicateName now ignores the spec/ directory, since there is a strong convention for using have_* and be_* helper methods in RSpec. (@gylaz)Performance/TimesMap cop can auto-correct. (@lumeet)Style/ZeroLengthPredicate cop can auto-correct. (@lumeet)Style/ConditionalAssignment is now configurable to enforce assignment inside of conditions or to enforce assignment to conditions. (@rrosenblum)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)Style/SpaceAroundKeyword should allow yield[n] and super[n]. (@laurelfan)Style/OneLineConditional. (@lumeet)if-then in Style/Next. (@lumeet)Style/RedundantParentheses doesn't flag -(1.method) or +(1.method), since removing the parentheses would change the meaning of these expressions. (@alexdowad)Style/MultilineMethodCallIndentation doesn't fail when inspecting unary ops which span multiple lines. (@alexdowad)Lint/LiteralInInterpolation doesn't report offenses for iranges and eranges with non-literal endpoints. (@alexdowad)Lint/AssignmentInCondition catches method assignments (like obj.attr = val) in a condition. (@alexdowad)===, <=, and >= in Style/ConditionalAssignment. (@rrosenblum)"#{$!}" in Style/SpecialGlobalVars. (@lumeet)SafeYAML.load is private. (@jonas054)require: only does relative includes when it starts with a .. (@ptarjan)Style/IfUnlessModifier does not trigger if the body is another conditional. (@amuino)Performance/RedundantMerge will now register an offense inside of each_with_object. (@rrosenblum)Style/UnlessElse cop can auto-correct. (@lumeet)highlighted_area to offense. This method returns the range of the highlighted portion of an offense. (@rrosenblum)Style/OneLineConditional cop can auto-correct. (@lumeet)Style/ZeroLengthPredicate flags code like array.length < 1, 1 > array.length, and so on. (@alexdowad)Lint/BlockAlignment cop can be configured to be stricter. (@ptarjan)Style/Not is able to auto-correct 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)require 'time' to remote_config.rb to avoid "undefined method `rfc2822'". (@necojackarc)Rake::TaskManager#last_comment with Rake::TaskManager#last_description for Rake 11 compatibility. (@tbrisker)Style/TrailingCommaInArguments & Style/TrailingCommaInLiteral cops with consistent_comma style. (@meganemura)Style/SpaceAroundKeyword for rescue(.... (@rrosenblum)Style/MultilineOperationIndentation treats operations inside blocks inside other operations correctly. (@jonas054)require: in config to be relative to the .rubocop.yml file itself. (@ptarjan)Style/MultilineLiteralBraceLayout auto-correct. (@jonas054)Style/MultilineArrayBraceLayout auto-correct. (@jonas054)Style/TrivialAccessors allows predicate methods by default. (@alexdowad)when clause with multiple arguments will not be missed. (@alexdowad)Lint/UselessAccessModifier recognizes method defs inside a begin block. (@alexdowad)Lint/UselessAccessModifier recognizes method definitions which are passed as an argument to a method call. (@alexdowad)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)Performance/Casecmp doesn't flag uses of downcase/upcase which are not redundant. (@alexdowad)Style/FileName doesn't choke on empty files with spaces in their names. (@alexdowad)ConsistentQuotesInMultiline: true, Style/StringLiterals doesn't error out when inspecting a heredoc with differing indentation across multiple lines. (@alexdowad)Style/ConditionalAssignment behaves correctly when assignment statement uses a character which has a special meaning in a regex. (@alexdowad)Style/SpaceAroundKeyword doesn't flag !super.method, !yield.method, and so on. (@alexdowad)Style/Encoding can remove unneeded encoding comment when auto-correcting with when_needed style. (@alexdowad)Rails/Date when to_time is chained with safe method. (@palkan)Lint/NestedMethodDefinition allows methods defined inside Class.new(S) blocks. (@segiddins)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)ASCII-8BIT encoding and output as HTML or JSON. (@jonas054)ENV['HOME'] is undefined. (@mikegee)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)expression instead of keyword (the offense now spans the entire method, class, or module). (@rrosenblum)options, formatters, and requires arrays. (@alexdowad)Style/SignalException does not flag calls to fail if a custom method named fail is defined in the same file. (@alexdowad)Style/FileName considers file names which contain a ? or ! character to still be "snake case". (@alexdowad)Lint/UnusedMethodArgument removes unused block arguments rather than simply prefixing them with an underscore. (@alexdowad)Lint/LiteralInInterpolation. (@lumeet)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)Performance/RedundantMerge doesn't break code by auto-correcting a #merge! call which occurs at tail position in a block. (@alexdowad)Lint/LiteralInInterpolation. (@lumeet)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)Style/ConditionalAssignment handles correcting the alignment of end. (@rrosenblum)not with parentheses in Style/Not. (@lumeet)super { ... } and super(arg) { ... }. (@alexdowad)Performance/RedundantMerge doesn't flag calls to #update, since many classes have methods by this name (not only Hash). (@alexdowad)Lint/DuplicateMethods does not flag method definitions inside dynamic Class.new blocks. (@alexdowad)Style/SpaceAroundKeyword doesn't flag yield.method. (@alexdowad)Style/SpaceAroundOperators doesn't flag calls to #[]. (@alexdowad)AllCops section in configuration file is empty (rather, it displays a warning as intended). (@alexdowad)Style/GuardClause handles elsif clauses correctly. (@alexdowad)Style/MultilineBlockLayout doesn't cause an infinite loop by moving end onto the same line as the block args. (@alexdowad)Performance/RedundantMatch doesn't flag calls to #match which take a block. (@alexdowad)Lint/NestedMethodDefinition doesn't flag singleton defs which define a method on the value of a local variable. (@alexdowad)Style/TrailingUnderscoreVariable shows recommended code in its offense message. (@alexdowad)Style/WordArray doesn't attempt to inspect strings with invalid encoding, to avoid failing with an encoding error. (@alexdowad)when_needed in Style/FrozenStringLiteralComment to add a frozen_string_literal comment to all files when the TargetRubyVersion is set to 2.3+. (@rrosenblum)Style/ZeroLengthPredicate checks for object.size == 0 and variants, and suggests replacing them with an appropriate empty? predicate. (@drenmi)Style/SpaceAroundKeyword cop. (@lumeet)Style/MultilineHashBraceLayout checks that the closing brace in a hash literal is symmetrical with respect to the opening brace and the hash elements. (@panthomakos)Style/MultilineMethodDefinitionBraceLayout checks that the closing brace in a method definition is symmetrical with respect to the opening brace and the method parameters. (@panthomakos)Performance/Casecmp can register offenses when str.downcase or str.upcase are passed to an equality method. (@rrosenblum)Style/MultilineMethodCallBraceLayout checks that the closing brace in a method call is symmetrical with respect to the opening brace and the method arguments. (@panthomakos)Style/Semicolon can auto-correct useless semicolons at the beginning of a line. (@alexdowad)Performance/RedundantMerge. (@drenmi)Style/MutableConstant. (@segiddins)||= in Style/MutableConstant. (@segiddins)Style/ConditionalAssignment. (@segiddins)casecmp in Performance/casecmp. (@segiddins)xstr interpolations in Lint/LiteralInInterpolation. (@segiddins)freeze is called on a frozen string literal in Style/RedundantFreeze. (@segiddins)Performance/RedundantBlockCall. (@segiddins)Lint/DuplicateMethods doesn't crash when class_eval is used with an implicit receiver. (@lumeet)Style/RedundantParentheses. (@lumeet)Style/Next doesn't crash when auto-correcting modifier if/unless. (@lumeet)Performance/TimesMap for calling map or collect on a variable named times. (@rrosenblum)Performance/RedundantBlockCall to respect parentheses usage. (@rrosenblum)Lint/NestedMethodDefinition to respect Class.new and Module.new. (@owst)Style/NestedModifier adds parentheses around a condition when needed. (@lumeet)Lint/LiteralInInterpolation. (@lumeet)Performance/Casecmp can auto-correct case comparison to variables and method calls without error. (@rrosenblum)Style/RedundantParentheses. (@lumeet)Style/IndentationWidth, Style/ElseAlignment, Lint/EndAlignment, and Lint/DefEndAlignment. (@jonas054)Style/MultilineOperationIndentation. (@jonas054)rescue in Style/RedundantParentheses. (@rrosenblum)Style/TrailingCommaInArguments & Style/TrailingCommaInLiteral for inline single element arrays. (@annih)not in Style/MethodCallParentheses. (@lumeet)Style/SpaceAfterControlKeyword and Style/SpaceBeforeModifierKeyword as the more generic Style/SpaceAroundKeyword handles the same cases. (@lumeet)!= in Performance/casecmp. (@segiddins)Style/FrozenStringLiteralComment on the version of Ruby that is running. (@rrosenblum)Style/SignalException to only_raise. (@bbatsov)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)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)Performance/TimesMap checks for x.times.map{} and suggests replacing them with Array.new(x){}. (@DNNX)Lint/NextWithoutAccumulator finds bare next in reduce/inject blocks which assigns nil to the accumulator. (@mvidner)AllowHeredoc to Metrics/LineLength. (@fphilipe)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)Style/IndentAssignment checks the indentation of the first line of the right-hand-side of a multi-line assignment. (@panthomakos)IgnoreExecutableScripts option to Style/FileName. (@sometimesfood)Style/UnneededInterpolation checks for strings that are just an interpolated expression. (@cgriego)Style/MultilineAssignmentLayout cop checks for a newline after the assignment operator in a multi-line assignment. (@panthomakos)Lint/UselessAccessModifier can catch more types of useless access modifiers. (@alexdowad)Performance/Casecmp cop. (@alexdowad)Performance/RangeInclude cop. (@alexdowad)Performance/RedundantSortBy cop. (@alexdowad)Performance/LstripRstrip cop. (@alexdowad)Performance/StartWith cop. (@alexdowad)Performance/EndWith cop. (@alexdowad)Performance/RedundantMerge cop. (@alexdowad)Lint/Debugger cop can now auto-correct offenses. (@alexdowad)Performance/RedundantMatch cop. (@alexdowad)Performance/RedundantBlockCall cop. (@alexdowad)Lint/UnneededDisable can now auto-correct. (@alexdowad)Lint/ImplicitStringConcatenation cop. (@alexdowad)Style/RedundantParentheses cop. (@lumeet)Style/SpecialGlobalVars can be configured to use either use_english_names or use_perl_names styles. (@alexdowad)Style/NestedParenthesizedCalls cop checks for non-parenthesized method calls nested inside a parenthesized call, like method1(method2 arg). (@alexdowad)--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)Style/GuardClause catches if..else nodes with one branch which terminates the execution of the current scope. (@alexdowad)Style/IdenticalConditionalBranches flags if..else and case..when..else constructs with an identical line at the end of each branch. (@alexdowad)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)EnforcedStyle is configured. (@alexdowad)Lint/IneffectiveAccessModifier checks for access modifiers which are erroneously applied to a singleton method, where they have no effect. (@alexdowad)Lint/BlockAlignment aligns block end with splat operator when applied to a splatted method call. (@alexdowad)task.options = %w(--format ...) is used when configuring RuboCop::RakeTask; this should be task.formatters = ... instead. (@alexdowad)--no-offense-counts CLI option suppresses the inclusion of offense count lines in auto-generated config. (@alexdowad)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)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)Style/Alias supports both prefer_alias and prefer_alias_method styles. (@alexdowad)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)Style/ConditionalAssignment to check and correct conditionals that contain multiple assignments. (@rrosenblum)Style/ConditionalAssignment to correct assignment in ternary operations. (@rrosenblum)Style/ConditionalAssignment to correct comparable methods. (@rrosenblum)Style/MultilineMethodCallIndentation takes over the responsibility for checking alignment of methods from the Style/MultilineOperationIndentation cop. (@jonas054)Style/MultilineArrayBraceLayout checks that the closing brace in an array literal is symmetrical with respect to the opening brace and the array elements. (@panthomakos)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)Style: Enabled: false. (@alexdowad)start_of_line style for Lint/EndAlignment aligns a closing end keyword with the start of the line where the opening keyword appears. (@alexdowad)Regex config parameter for Style/FileName allows user to provide their own regex for validating file names. (@alexdowad)DefaultFormatter config parameter can be used to set formatter from within .rubocop.yml. (@alexdowad)WorstOffendersFormatter prints a list of files with offenses (and offense counts), showing the files with the most offenses first. (@alexdowad)IfInsideElse cop catches if..end nodes which can be converted into an elsif instead, reducing the nesting level. (@alexdowad)ConsistentQuotesInMultiline config param for Style/StringLiterals forces all literals which are concatenated using \ to use the same quote style. (@alexdowad)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)Performance/HashEachMethods cop. (@ojab)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)Style/EmptyLiteral auto-corrector respects Style/StringLiterals:EnforcedStyle config. (@DNNX)%Q for dynamic strings with double quotes inside them. (@jonas054)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)Time.zone.current with Time.current on Rails::TimeZone cop message. (@volmer)Style/StabbyLambdaParentheses does not treat method calls named lambda as lambdas. (@domcleal)Style/MethodName doesn't choke on methods which are defined inside methods. (@alexdowad)Style/StabbyLambdaParentheses only checks lambdas in the arrow form. (@lumeet)Lint/NestedMethodDefinition doesn't register offenses for method definitions inside an eval block (either instance_eval, class_eval, or module_eval). (@alexdowad)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)Style/AndOr doesn't raise an exception when trying to auto-correct !variable or .... (@alexdowad)Style/Tab doesn't register errors for leading tabs which occur inside a string literal (including heredoc). (@alexdowad)Style/TrailingComma incorrectly categorizes single-line hashes in methods calls. (@panthomakos)Style/AlignParameters doesn't crash if it finds nested offenses. (@alexdowad)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)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)Lint/FormatParameterMismatch understands %{} and %<> interpolations. (@alexdowad)Lint/ParenthesesAsGroupedExpression ignores calls with multiple arguments, since they are not ambiguous. (@alexdowad)Lint/UselessAccessModifier doesn't think that an access modifier applied to attr_writer is useless. (@alexdowad)Style/ConditionalAssignment doesn't think that branches using << and []= should be combined. (@alexdowad)CharacterLiteral auto-corrector now properly corrects ?'. (@bfontaine)Rails/FindEach doesn't break code which uses order(...).each, limit(...).each, and so on. (@alexdowad)Rails/FindBy doesn't auto-correct where(...).first to find_by, since the returned record is often different. (@alexdowad)EmacsFormatter strips newlines out of error messages, if there are any. (@alexdowad)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)Lint/FormatParameterMismatch understands format specifiers with multiple flags. (@alexdowad)Style/SpaceAroundOperators doesn't eat newlines. (@alexdowad)Style/AndOr auto-corrects in cases where parentheses must be added, even inside a nested begin node. (@alexdowad)Style/Next adjusts indentation when auto-correcting, to avoid introducing new offenses. (@alexdowad)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)rubocop:disable comments (not the single line kind) for a given cop appear in a file with no rubocop:enable in between. (@jonas054)Style/Encoding can auto-correct files with a blank first line. (@alexdowad)Style/SpecialGlobalVariables generates auto-config correctly. (@alexdowad)Style/SpaceAroundOperators leave spacing around => to Style/AlignHash. (@jonas054)Style/MethodCallParentheses doesn't register warnings for object.() syntax, since it is handled by Style/LambdaCall. (@alexdowad)Performance/RedundantMerge doesn't break code with a modifier if when auto-correcting. (@alexdowad)Performance/RedundantMerge doesn't break code with a modifier while or until when auto-correcting. (@alexdowad)variable style for Lint/EndAlignment is working again. (@alexdowad)Lint/EndAlignment can auto-correct 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)Style/StringReplacement doesn't break code when auto-correction involves a regex with embedded escapes (like /\n/). (@alexdowad)Style/AlignHash doesn't move a key so far left that it goes onto the previous line (in an attempt to align). (@alexdowad)Style/SymbolProc doesn't break code when auto-correcting a method call with a trailing comma in the argument list. (@alexdowad)Style/TrailingCommaInArguments and Style/TrailingCommaInLiteral don't special-case single-item lists in a way which contradicts the documentation. (@alexdowad)Style/FileName doesn't fail on empty files when ExpectMatchingDefinition is true. (@alexdowad)Style/RedundantFreeze registers offences for frozen dynamic symbols. (@segiddins)AutoCorrectUnlessChangingAST module can now auto-correct files which contain __FILE__. (@alexdowad)Style/ConditionalAssignment can auto-correct =~ within a ternary expression. (@alexdowad)some-random-script) for Ruby scripts that have a shebang. (@sometimesfood)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)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)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)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)RunRailsCops config parameter in .rubocop.yml is now obsolete. If someone attempts to use it, config validation will fail with a helpful message. (@alexdowad)Exclude config parameters in .rubocop.yml will be merged into the generated .rubocop_todo.yml. (@alexdowad)Rails/DefaultScope cop. (@alexdowad)TargetRubyVersion configuration parameter can be used to specify which version of the Ruby interpreter the inspected code is intended to run on. (@alexdowad)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)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)ExtraDetails supports addition of Details param to all cops to allow extra details on offense to be displayed. (@tansaku)Style/StabbyLambdaParentheses will find and correct cases where a stabby lambda's parameters are not wrapped in parentheses. (@hmadison)Style/TrailingUnderscoreVariable will now register an offense for *_. (@rrosenblum)Style/TrailingUnderscoreVariable now has a configuration to remove named underscore variables (Defaulted to false). (@rrosenblum)Performance/FixedSize will register an offense when calling length, size, or count on statically sized objected (strings, symbols, arrays, and hashes). (@rrosenblum)Style/NestedModifier checks for nested if, unless, while and until modifier statements. (@lumeet)inherit_gem configuration to inherit a config file from an installed gem (originally requested in #290). (@jhansche)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)Lint/Debugger cop now checks for Pry.rescue. (@rrosenblum)Style/FirstArrayElementLineBreak checks for a line break before the first element in a multi-line array. (@panthomakos)Style/FirstHashElementLineBreak checks for a line break before the first element in a multi-line hash. (@panthomakos)Style/FirstMethodArgumentLineBreak checks for a line break before the first argument in a multi-line method call. (@panthomakos)Style/FirstMethodParameterLineBreak checks for a line break before the first parameter in a multi-line method parameter definition. (@panthomakos)Rails/PluralizationGrammar cop, checks for incorrect grammar when using methods like 3.day.ago, when you should write 3.days.ago. (@maxjacobson)Lint/Eval cop does not warn about "security risk" when eval argument is a string literal without interpolations. (@alexdowad)Style/VariableName cop checks naming style of method parameters. (@alexdowad)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)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)IgnoreEmptyMethods config parameter for Lint/UnusedMethodArgument and IgnoreEmptyBlocks config parameter for Lint/UnusedBlockArgument cops. (@alexdowad)Style/MethodDefParentheses supports new 'require_no_parentheses_except_multiline' style. (@alexdowad)Style/AlignParameters also checks parameter alignment for method definitions. (@alexdowad)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)Style/IndentHash. (@alexdowad)Style/Next can auto-correct. (@alexdowad)+ in ExtraSpacing cop. (@jonas054)Exclude into Exclude lists in .rubocop_todo.yml. (@jonas054)Style/IfUnlessModifier accepts blocks followed by a chained call. (@lumeet)Exclude paths in $HOME/.rubocop_todo.yml be relative to current directory. (@jonas054)AllowIfMethodIsEmpty is false in Style/SingleLineMethods. (@jonas054)Style/TrailingUnderscoreVariable when the underscore variable is preceded by a splat variable. (@rrosenblum)Style/ExtraSpacing. (@jonas054)ConfigurableNaming#class_emitter_method? error when handling singleton class methods. (@palkan)Performance/StringReplacement for regex with options. (@rrosenblum)Style/UnneededPercentQ condition for single-quoted literal containing interpolation-like string. (@eagletmt)--only Lint/Syntax and --except Lint/Syntax correctly. (@jonas054)case as an argument correctly in Lint/EndAlignment. (@lumeet)Style/IndentationWidth. (@lumeet)Performance/Size for count with an argument. (@rrosenblum)Style/SpaceAroundOperators. (@lumeet)Lint/FormatParameterMismatch, don't register an offense if either argument to % is not a literal. (@alexdowad)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)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)Lint/NonLocalExitFromIterator does not warn about return in a block which is passed to Module#define_method. (@alexdowad)Rainbow reference with Colorizable#yellow. (@minustehbare)Style/Copyright is misconfigured. (@alexdowad)Style/EachWithObject, don't replace reduce with each_with_object if the accumulator parameter is assigned to in the block. (@alexdowad)Lint/UselessAssignment doesn't erroneously identify assignments in identical if branches as useless. (@alexdowad)Style/IfUnlessModifier cop parenthesizes auto-corrected code when necessary due to operator precedence, to avoid changing its meaning. (@alexdowad)Lint/UnneededDisable work with --auto-correct. (@jonas054)Style/MethodCallParentheses doesn't fail on obj.method ||= func(). (@alexdowad)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)Lint/FormatParameterMismatch for argument with splat operator. (@dreyks)Lint/FormatParameterMismatch to be called using Kernel.format and Kernel.sprintf. (@rrosenblum)Lint/FormatParameterMismatch when the format string is a variable. (@rrosenblum)Lint/UnneededDisable should not report non-Lint rubocop:disable comments when running rubocop --lint. (@jonas054)Style/ExtraSpacing to avoid correction conflict. (@jonas054)Performance/CaseWhenSplat for percent arrays (%w, %W, %i, and %I). (@rrosenblum)Style/CommentAnnotation if they don't start a comment. (@jonas054)Style/RescueEnsureAlignment will register an offense for rescue and ensure on the same line. (@rrosenblum)Style/SymbolProc. (@bbatsov)Exclude in .rubocop_todo.yml work when running from a subdirectory. (@jonas054)Style/AutoResourceCleanup. (@lumeet)Style/Documentation will exclude test directories by default. (@rrosenblum)Style/StringMethods by default. (@bbatsov)File name too long error when STDIN option is provided. (@mrfoto)Style/SymbolProc. (@lumeet)Kernel) in Style/SignalException. (@lumeet)Performance/CaseWhenSplat will identify and rearrange case when statements that contain a when condition with a splat. (@rrosenblum)Lint/DuplicatedKey checks for duplicated keys in hashes, which Ruby 2.2 warns against. (@sliuu)SuspiciousParamNames option to Style/OptionHash. (@wli)Style/Next supports more Enumerable methods. (@rrosenblum)--list-target-files option to CLI, which prints the files which will be inspected. (@maxjacobson)Style/MutableConstant checks for assignment of mutable objects to constants. (@bbatsov)Style/RedundantFreeze checks for usages of Object#freeze on immutable objects. (@bbatsov)--cache and configuration parameter AllCops: UseCache turn result caching on (default) or off. (@jonas054)Style/StringMethods will check for preferred method to_sym over intern. (@imtayadeway)Style/MethodName. (@jonas054)Style/RescueModifier can now auto-correct. (@rrosenblum)Style/ExtraSpacing. (@jonas054)Lint/EndAlignment handles the case keyword. (@lumeet)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. (@MGerrior)Style/Next to highlight the condition instead of the iteration. (@rrosenblum)Style/EmptyLineBetweenDefs now handles class methods as well. (@unmanbearpig)super in Style/SymbolProc. (@lumeet)Style/SymbolProc is applied to methods receiving arguments. (@lumeet)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)Lint/FormatParameterMismatch. (@edmz)Lint/FormatParameterMismatch. (@edmz)super and zsuper nodes in Style/SymbolProc. (@bbatsov)Style/Alias. (@bbatsov)Rails/TimeZone. (@bbatsov)Rails/Date. (@bbatsov)Style/OptionHash. (@wli)Style/ParallelAssignment for nested expressions. (@rrosenblum)Style/InitialIndentation. (@jonas054)Style/ExtraSpacing. (@jonas054)Style/SpaceInsideStringInterpolation. (@lumeet)Style/RescueEnsureAlignment and Style/RescueModifier when processing an excluded file. (@rrosenblum)Rails/Date when Date#to_time is called with a time zone argument. (@maxjacobson)Rails/TimeZone offense when using Time.new safely. (@maxjacobson)Style/EmptyLineBetweenDefs when there are only comments between method definitions. (@lumeet)Performance/StringReplacement can auto-correct replacements with backslash in them. (@rrosenblum)RuboCop::ConfigLoader.load_file when safe_yaml is required. (@eitoball)EndAlignment: AlignWith: variable only applies when the operands of = are on the same line. (@jonas054)Style/IndentationWidth when rescue or ensure is preceded by an empty body. (@lumeet)Style/BlockDelimiters when auto-correcting adjacent braces. (@lumeet)rubocop exit with error when there are only Lint/UnneededDisable offenses. (@jonas054)Style/SymbolProc. (@lumeet)Style/Send checks for the use of send and instead encourages changing it to BasicObject#__send__ or Object#public_send (disabled by default). (@syndbg)Lint/FormatParameterMismatch checks for a mismatch between the number of fields expected in format/sprintf/% and what was passed to it. (@edmz)space style for SpaceInsideStringInterpolation. (@gotrevor)def, not only visibility modifiers. (@fphilipe)--auto-gen-config now outputs an excluded files list for failed cops (up to a maximum of 15 files). (@bmorrall)--exclude-limit COUNT to configure how many files --auto-gen-config will exclude. (@awwaiid, @jonas054)AllCops:DisabledByDefault when set to true makes only cops found in user configuration enabled, which makes cop selection opt-in. (@jonas054)Performance/StringReplacement checks for usages of gsub that can be replaced with tr or delete. (@rrosenblum)Style/InitialIndentation checks for indentation of the first non-blank non-comment line in a file. (@jonas054)Style/RescueEnsureAlignment checks for bad alignment of rescue and ensure keywords. (@lumeet)Style/OptionalArguments checks for optional arguments that do not appear at the end of an argument list. (@rrosenblum)Lint/CircularArgumentReference checks for "circular argument references" in keyword arguments, which Ruby 2.2 warns against. (@maxjacobson, @sliuu)Style/OptionHash checks for option hashes and encourages changing them to keyword arguments (disabled by default). (@maxjacobson)Style/RescueModifier uses token stream to identify offenses. (@urbanautomaton)Rails/Date and Rails/TimeZone style names to "strict" and "flexible" and make "flexible" to be default. (@palkan)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)Style/TrivialAccessors to support AllowPredicates: false. (@gotrevor)Style/ParallelAssignment when assigning from Module::CONSTANT. (@rrosenblum)Rails/TimeZone. (@palkan)Rails/Date and Rails/TimeZone when using namespaced Time/Date. (@palkan)Performance/Detect when select is called on Enumerable::Lazy. (@palkan)end in a file with only one method. (@jonas054)Time.current when style is "acceptable". (@palkan)Style/RedundantReturn auto-corrects returning implicit hashes to invalid syntax. (@rrosenblum)Style/BlockDelimiters when a semantic expression is used in an array or a range. (@lumeet)Style/MethodCallParentheses. (@lumeet)Style/IndentationWidth when using private_class_method def self.foo syntax. (@unmanbearpig)Style/FirstParameterIndentation in case of nested offenses. (@unmanbearpig)Style/PercentLiteralDelimiters with escape characters in them. (@rrosenblum)IndentationWidth. (@jonas054)Performance/Count when calling select..count in a class that extends an enumerable. (@rrosenblum)Style/OneLineConditional which should not raise an offense with an 'if/then/end' statement. (@sliuu)Debugger cop now checks catches methods called with arguments. (@crazydog115)Lint/UnneededDisable. (@jonas054)Lint/UnneededDisable when -D/--display-cop-names is given. (@jonas054)Style/NonNilCheck offenses as corrected when the source code is not modified. (@rrosenblum)Style/RedundantReturn when return has no arguments. (@lumeet)Style/TrailingComma cop. (@mattjmcnaughton)RedundantBegin auto-correct issue with comments by doing a smaller correction. (@jonas054)FirstParameterIndentation. (@tejasbubane)Lint/UnneededDisable to be inline disabled. (@rrosenblum)TrailingComma cop to account for multi-line hashes nested within method calls. (@panthomakos)SpaceInsideStringInterpolation checks for spaces within string interpolations. (@glasnt)NestedMethodDefinition checks for method definitions inside other methods. (@ojab)LiteralInInterpolation cop does auto-correction. (@tmr08c)Lint/UnneededDisable checks for rubocop:disable comments that can be removed. (@jonas054)EmptyElse cop does auto-correction. (@lumeet)Debugger cop now checks for the Capybara debug method save_screenshot. (@crazydog115)CaseIndentation cop does auto-correction. (@lumeet)SpaceInsideBlockBraces to SpaceBeforeSemicolon and SpaceAfterSemicolon to avoid an infinite loop when auto-correcting. (@lumeet)ParallelAssignment cop from Performance to Style. (@rrosenblum)getlocal to acceptable methods of Rails/TimeZone. (@ojab)ClassLength and ModuleLength to match that of MethodLength. (@bquorning)CountKeywordArgs: false for ParameterLists. (@sumeet)BracesAroundHashParameters. (@jonas054)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)ParallelAssignment to properly auto-correct when the assignment is protected by a modifier statement. (@rrosenblum)ParallelAssignment to work with non-standard IndentationWidths. (@rrosenblum)BracesAroundHashParameters. (@jonas054)IfUnlessModifier (and don't auto-correct them). (@jonas054), (fix for jruby and rbx). (@rrosenblum)return from lambda block in NonLocalExitFromIterator. (@ypresto)Style/Documentation. (@RGBD)for without body in Style/Next. (@bbatsov)Style/AlignHash when correcting a hash with a splat in it. (@rrosenblum)Symbol#to_proc blocks in Performance/Size. (@m1foley)Rails/TimeZone emits acceptable methods on a violation when EnforcedStyle is :acceptable. (@l8nite)ModuleLength checks for overly long module definitions. (@sdeframond)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)Style/TrailingUnderscoreVariable to remove trailing underscore variables from mass assignment. (@rrosenblum)Performance/ParallelAssignment to avoid usages of unnecessary parallel assignment. (@rrosenblum)DefEndAlignment and EndAlignment cops do auto-correction. (@lumeet)IndentationWidth cop follows the AlignWith option of the DefEndAlignment cop. (@lumeet)EachWithObjectArgument checks that each_with_object isn't called with an immutable object as argument. (@jonas054)ArrayJoin cop does auto-correction. (@tmr08c)Sample when calling #shuffle with something other than an element selector. (@rrosenblum)DefEndAlignment recognizes preceding private_class_method or public_class_method before def. (@til)AlignHash for when to ignore a key because it's not on its own line. (@jonas054)Sample and FlatMap that would cause them to report having been auto-corrected when they were not. (@rrosenblum)UnusedMethodArgument that would cause them to report having been auto-corrected when they were not. (@jonas054)Auto-Correct configuration parameter, and remove warning for unknown parameter. (@jonas054)TrailingBlankLines when a file ends with a block comment without final newline. (@jonas054)MultilineTernaryOperator where it will not register an offense when only the false branch is on a separate line. (@rrosenblum)MultilineBlockLayout when using new lambda literal syntax without parentheses. (@hbd225)IfUnlessModifier concerning comments and empty lines. (@jonas054)SpaceAroundBlockParameters and SpaceAfterComma. (@lumeet)=, use keyword alignment in EndAlignment regardless of configured style. (@jonas054)LiteralInInterpolation registers an offense for interpolation of __LINE__. (@rrosenblum)Rails/TimeZone. (@palkan)PercentLiteralDelimiters with no content. (@cshaffer)while and until with assignment in IndentationWidth. (@lumeet)TrailingComma that caused , in comment to count as a trailing comma. (@jonas054)parser and use its corrected solution for comment association in Style/Documentation. (@jonas054)Sample that did not account for array selectors with a range and passing random to shuffle. (@rrosenblum)Rails/TimeZone (utc, localtime, to_i, iso8601 etc). (@palkan)Performance/Detect. (@palkan)TrailingBlankLines that caused a crash for files containing only newlines. (@renuo)line_count_based and semantic styles to the BlockDelimiters (formerly Blocks) cop. (@clowder, @mudge)Offense#corrected? to true, false, or nil when it was, wasn't, or can't be auto-corrected, respectively. (@vassilevsky)--display-style-guide. (@marxarelli)HashStyle cop. (@iainbeeston)IgnoreClassMethods option to TrivialAccessors cop. (@bbatsov)Style/SpaceAroundOperators cop now also detects extra spaces around operators. A list of operators that may be surrounded by multiple spaces is configurable. (@bquorning)Encoding cop. (@rrosenblum)TrailingComma has a new style consistent_comma. (@tamird)empty, nil, and both SupportedStyles to EmptyElse cop. Default is both. (@rrosenblum)MissingElse cop. Default is to have this cop be disabled. (@rrosenblum)# :nodoc in Documentation. (@lumeet)HashSyntax cop to allow the use of hash rockets for hashes that have symbol values when using ruby19 syntax. (@rrosenblum)Style/SymbolLiteral makes sure you're not using the string within symbol syntax unless it's needed. (@bbatsov)Style/AutoResourceCleanup suggests the use of block taking versions of methods that do resource cleanup. (@bbatsov)WhileUntilModifier cop does auto-correction. (@lumeet)Performance/ReverseEach to convert reverse.each to reverse_each. (@rrosenblum)IfUnlessModifier cop does auto-correction. (@lumeet)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)NonLocalExitFromIterator checks for misused return in block. (@ypresto)Performance/Size to convert calls to count on Array and Hash to size. (@rrosenblum)Performance/Sample to convert usages of shuffle.first, shuffle.last, and shuffle[Fixnum] to sample. (@rrosenblum)Performance/FlatMap to convert Enumerable#map...Array#flatten and Enumerable#collect...Array#flatten to Enumerable#flat_map. (@rrosenblum)ClosingParenthesisIndentation checks the indentation of hanging closing parentheses. (@jonas054)FindBy identifies usages of where.first and where.take. (@bbatsov)FindEach identifies usages of all.each. (@bbatsov)IndentationConsistency is now configurable with the styles normal and rails. (@jonas054)MissingElse cop. (@gerry3)blockarg in TrivialAccessors. (@bbatsov):"string" in HashSyntax. (@bbatsov)begin blocks in Lint/Void. (@bbatsov)Lint/Void. (@bbatsov)--auto-gen-config and SpaceInsideBlockBraces. (@meganemura)BlockAlignment. (@lumeet)Lambda when a new multi-line lambda is used as an argument. (@lumeet)LiteralInInterpolation and AssignmentInCondition. (@ypresto)LineEndConcatenation auto-correct. (@jonas054)__END__. (@jonas054)Style/Documentation. (@lumeet)binding calls in UnusedBlockArgument and UnusedMethodArgument. (@lumeet)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)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)Style/TrivialAccessors now requires matching names by default. (@bbatsov)FirstParameterIndentation. (@jonas054)SpaceAroundBlockParameters when lambda has no argument. (@eitoball)UselessSetterCall. (@bbatsov),. (@bquorning)--except option for disabling cops on the command line. (@jonas054)EvenOdd cop. (@blainesch)Debugger cop now checks for the Capybara debug methods save_and_open_page and save_and_open_screenshot. (@rrosenblum)AllCops/DisplayCopNames configuration option for showing cop names in reports, like --display-cop-names. (@jonas054)Lambda cop does auto-correction. (@lumeet)Lint, in the arguments to --only and --except. (@jonas054)SelfAssignment cop does auto-correction. (@lumeet)RedundantException. (@mattjmcnaughton)StructInheritance checks for inheritance from Struct.new. (@mmozuras)DuplicateMethods points out duplicate method name in class and module. (@d4rk5eed)FirstParameterIndentation checks the indentation of the first parameter in a method call. (@jonas054)SpaceAroundBlockParameters checks the spacing inside and after block parameters pipes. (@jonas054)-e/--emacs and -s/--silent are no longer recognized. Using them will now raise an error. (@bquorning)--fail-level A cause exit with error if all offenses are auto-corrected. (@jonas054)MultilineBlockLayout. (@lumeet)PerlBackrefs cop auto-corrections to not raise. (@cshaffer)Style/EmptyLinesAroundAccessModifier interfered with Style/EmptyLinesAroundBlockBody when there is and access modifier at the beginning of a block. (@volkert)Lint/AssignmentInCondition. (@jonas054)EmptyLinesAroundAccessModifier incorrectly finding a violation inside method calls with names identical to an access modifier. (@dblock)Exclude properties inherited from a higher directory level. (@jonas054)--auto-correct --only IndentationWidth. (@jonas054)auto_correct Rake tasks does not take in the options specified in its parent task. (@rrosenblum)LineEndConcatenation. (@yujinakayama, @jonas054)BracesAroundHashParameter leave the correct number of spaces. (@mattjmcnaughton)[Corrected] when auto-correction was avoided in Style/Semicolon. (@jonas054)BlockAlignment. (@lumeet)Hash.new to {} when braces would be interpreted as a block. (@jonas054)[] in MultilineOperationIndentation. (@jonas054)Rails/Delegate. (@bbatsov)@example warnings in Yard Doc documentation generation. (@mattjmcnaughton)[Corrected] when auto-correction was avoided in TrivialAccessors. (@lumeet)expand_path on inherit_from in .rubocop.yml. (@mattjmcnaughton)Style/ClassMethods. (@bbatsov)ExtraSpacing points out unnecessary spacing in files. (@blainesch)EmptyLinesAroundBlockBody provides same functionality as the EmptyLinesAround(Class|Method|Module)Body but for blocks. (@jcarbo)Style/EmptyElse checks for empty else-clauses. (@Koronen)--only-guide-cops and AllCops/StyleGuideCopsOnly options that will only enforce cops that link to a style guide. (@marxarelli)context_dependent for Style/BracesAroundHashParameters looks at preceding parameter to determine if braces should be used for final parameter. (@jonas054)--auto-correct, only offenses that cannot be corrected will result in a non-zero exit code. (@jonas054)#=) in Style/LeadingCommentSpace. (@bbatsov)%W[] auto corrected to %w(]. (@toy)Style/StringLiterals cop stays away from strings inside interpolated expressions. (@jonas054)Style/Blocks and other cops to determine if an auto-correction would alter the meaning of the code. (@jonas054)MultilineOperationIndentation where instances of both correct style and unrecognized (plain wrong) style are detected during an --auto-gen-config run. (@jonas054)SymbolProc when there are multiple offenses on the same line. (@jcarbo)--auto-correct for NegatedWhile. (@jonas054)#$1 in PerlBackrefs. (@bbatsov)#$: in SpecialGlobalVars. (@bbatsov)SingleLineBlockParams. (@jonas054)elsif + else in ElseAlignment. (@jonas054)<< and \ caught by Style/LineEndConcatenation cop. (@katieschilling)SymbolProc. (@bbatsov)Style/MultilineOperationIndentation doesn't recognize assignment to array/hash element. (@jonas054)RescueException cop. (@bbatsov)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)MultilineOperationIndentation. (@bbatsov)StringLiteralsInInterpolation. (@jonas054)begin/rescue/else/end in ElseAlignment. (@jonas054)MultilineIfThen. (@janraasch, @jonas054)SpaceInsideRangeLiteral. (@bbatsov)ElseAlignment checks alignment of else and elsif keywords. (@jonas054)MultilineOperationIndentation checks indentation/alignment of binary operations if they span more than one line. (@jonas054)Metrics/AbcSize checks the ABC metric, based on assignments, branches, and conditions. (@jonas054, @jfelchner)WordArray is now configurable with the WordRegex option. (@bquorning)Style/StringLiteralsInInterpolation checks quotes inside interpolated expressions in strings. (@jonas054)Style/IndentationWidth is now configurable with the Width option. (@jonas054).opal files by default. (@bbatsov)Style cops, EmptyLinesAroundMethodBody , EmptyLinesAroundClassBody , and EmptyLinesAroundModuleBody replace the EmptyLinesAroundBody cop. (@jonas054)AlignHash no longer skips multiline hashes that contain some elements on the same line. (@mvz)BracesAroundHashParameters no longer cleans up whitespace in auto-correct, as these extra corrections are likely to interfere with other cops' corrections. (@jonas054)Blocks cop introducing syntax errors in auto-correct. (@jonas054)FormatString. (@bbatsov)--out to create parent directories. (@yous)ColonMethodCall. (@bbatsov)SpaceInsideParens with detecting space inside parentheses used for grouping expressions. (@jonas054)LineLength when AllowURI is enabled. (@smangelsdorf)eql? and equal? in OpMethod. (@bbatsov)Style/SymbolProc cop when the block calls a method with no explicit receiver. (@smangelsdorf)HTMLFormatter generates a html file with a list of files with offences in them. (@SkuliOskarsson)SpaceInsideRangeLiteral checks for spaces around .. and ... in range literals. (@bbatsov)InfiniteLoop checks for places where Kernel#loop should have been used. (@bbatsov)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 prefixes that denote predicate method names and predicate prefixes that should be removed. (@bbatsov)Tab cop does auto-correction. (@yous)MultilineIfThen cop does auto-correction. (@bbatsov)DotPosition cop does auto-correction. (@yous)SpaceBeforeFirstArg cop does auto-correction. (@yous)module_function in Style/AccessModifierIndentation and Style/EmptyLinesAroundAccessModifier. (@bbatsov)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)%W literals with special escaped characters in UnneededCapitalW. (@jonas054)VariableName. (@bbatsov)UselessAssignment when there's a reference for the variable in an exclusive branch. (@yujinakayama)RedundantBegin cop deletes new line. (@yous)PercentLiteralDelimiters. (@jonas054)BracesAroundHashParameters auto-correction removes whitespace around content inside braces. (@jspanjers)AndOr when enforced style is conditionals. (@bbatsov)while and until in AndOr when enforced style is conditionals. (@yujinakayama)FormatString. (@bbatsov)AndOr to restrict it to conditionals. (@vrthra)PercentQLiterals checks if use of %Q and %q matches configuration. (@jonas054)BarePercentLiterals checks if usage of %() or %Q() matches configuration. (@jonas054)MultilineBlockLayout checks if a multiline block has an expression on the same line as the start of the block. (@barunio)Style::EmptyLinesAroundAccessModifier cop does auto-correction. (@tamird)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)MinBodyLength option to Next cop. (@bbatsov)TrailingComma cop does auto-correction. (@yous)BlockEndNewline checks if the end statement of a multiline block is on its own line. (@barunio)BlockAlignment cop does auto-correction. (@barunio)Metrics created and some Style cops moved there. (@jonas054)PercentLiteralDelimiters auto-correct indentation error. (@hannestyden)SpaceInsideBlockBraces. (@jonas054)UnneededPercentQ for /%Q(something)/. (@jonas054)SpacesInsideBrackets for Hash#[] calls with spaces after left bracket. (@mcls)UnneededPercentQ for %Q(\t"). (@jonas054)UnneededPercentQ for heredoc strings with %q/%Q. (@jonas054)AlignHash auto-correct. (@jonas054)end or } in BlockAlignment if it doesn't begin its line. (@jonas054)Output cop. (@bbatsov)TrailingComma. (@tamird)Auto-CorrectUnlessChangingAST. (@jonas054)VariableInterpolation. (@bbatsov)--auto-correct crash in AlignParameters. (@jonas054)--auto-correct crash in IndentationWidth. (@jonas054)--only arguments later when all cop names are known. (@jonas054)LineLength cop when AllowURI option is enabled. (@yujinakayama)Next cop. (@yujinakayama)UselessSetterCall. (@yujinakayama)UnneededCapitalW cop does auto-correction. (@sfeldon)DefEndAlignment takes over responsibility for checking alignment of method definition ends from EndAlignment, and is configurable. (@jonas054)ClassCheck enforces consistent use of is_a? or kind_of?. (@bbatsov)SpaceBeforeComma detects spaces before a comma. (@agrimm)SpaceBeforeSemicolon detects spaces before a semicolon. (@agrimm)UnneededPercentQ checks for usage of the %q/%Q syntax when '' or "" would do. (@jonas054)AllowURI option (enabled by default) to LineLength cop. (@yujinakayama)obj.each { |arg; this| }) are now handled by UnusedBlockArgument cop instead of UselessAssignment cop. (@yujinakayama)TrailingComma that a trailing comma is never allowed for lists where some items share a line. (@jonas054)reduce/inject with no arguments in EachWithObject. (@bbatsov)while/until with no body in Next. (@tamird)UselessSetterCall for setter call on a local variable that contains a non-local object. (@yujinakayama)begin..end structures, blocks, and parenthesized expressions in IndentationWidth. (@jonas054)attr is considered an offense. (@jonas054)TrailingComma. (@jonas054)ParenthesesAroundCondition. (@bbatsov)return in a loop in Next cop. (@yujinakayama)rescue/else/ensure bodies in IndentationWidth. (@jonas054)when in IndentationWidth. (@jonas054)BlockComments cop does auto-correction. (@jonas054)TrivialAccessors cop auto-corrects class-level accessors. (@ggilder)InlineComment checks for inline comments. (@salbertson)IndentArray and IndentHash. (@jonas054)Style/LineLength instead of LineLength in config files, --only argument, --show-cops output, and # rubocop:disable. (@jonas054)Rubocop module to RuboCop. (@bbatsov)--auto-gen-config bug with RegexpLiteral where only the last file's results would be used. (@ggilder)EachWithObject with modifier if as body. (@geniou)EachWithObject with single method call as body. (@geniou)EndOfLine with reading non-UTF-8 encoded files. (@jonas054)Next to ignore super nodes. (@geniou)=begin..=end). (@jonas054)ParenthesesAroundCondition. (@jonas054)ParenthesesAroundCondition. (@bbatsov)CommentIndentation checks indentation of comments. (@jonas054)EachWithObject to prefer each_with_object over inject or reduce. (@geniou)Next check for conditions at the end of an iteration and propose to use next instead. (@geniou)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)UnneededPercentX checks for %x when backquotes would do. (@jonas054)UnusedBlockArgument and UnusedMethodArgument cops. (@hannestyden)SpaceBeforeComment checks for missing space between code and a comment on the same line. (@jonas054)-F/--fail-fast inspects files in modification time order and stop after the first file with offenses. (@jonas054)require directive to .rubocop.yml to load custom ruby files. (@geniou)NonNilCheck offense reporting and auto-correct are configurable to include semantic changes. (@hannestyden)AllCops/Excludes and AllCops/Includes with final s only give a warning and don't halt rubocop execution. (@jonas054)GuardClause cop is no longer ignoring a one-line body by default - see configuration. (@geniou)rubocop-todo.yml file to .rubocop_todo.yml. (@geniou)AlignParameters cop. (@tommeier)Void and SpaceAroundOperators for short call syntax lambda.(). (@biinari)Delegate for delegation with assignment or constant. (@geniou)--auto-correct. (@jonas054)__FILE__ in LineEndConcatenation. (@bbatsov)NegatedIf when the condition has parentheses around it. (@jonas054)AlignParameters with_fixed_indentation for multi-line method calls. (@molawson)Exclude setting in the cop's configuration. (@jonas054)Exclude config section not being recognized on Windows. (@wndhydrnt)UnneededCapitalW checks for %W when interpolation not necessary and %w would do. (@sfeldon)UnderscorePrefixedVariableName checks for _-prefixed variables that are actually used. (@yujinakayama)UnusedMethodArgument checks for unused method arguments. (@yujinakayama)UnusedBlockArgument checks for unused block arguments. (@yujinakayama)RedundantBegin cop does auto-correction. (@tamird)RescueException cop does auto-correction. (@tamird)TrivialAccessors cop does auto-correction. (@tamird)AllowDSLWriters options to TrivialAccessors. (@tamird)Debugger cop check for forgotten calls to byebug. (@bquorning)auto_correct task to Rake integration. (@irrationalfab)--only option can take a comma-separated list of cops. (@jonas054)Delegate that checks for delegations that could be replaced by the delegate method. (@geniou)Encoding cop to only enforce encoding comment if there are non ASCII characters. (@geniou)FinalNewline cop as its check is now performed by TrailingBlankLines. (@jonas054)Dir#[] for config parameters added. (@jonas054)LineEndConcatenation cop. (@mockdeep)IndentationWidth handling method calls. (@tamird)EndAlignment not handling element assignment correctly. (@tamird)IndentationWidth not handling element assignment correctly. (@tamird)[Corrected] in --auto-correct mode if correction wasn't done. (@jonas054)-c .rubocop.yml. (@bquorning)IndentationWidth. (@jonas054)--lint is used together with --only, all lint cops are run in addition to the given cops. (@jonas054)Exclude property when rubocop . is called. (@jonas054)private) and def on the same line (Ruby >= 2.1) in IndentationWidth. (@jonas054)--auto-gen-config logic for RegexpLiteral. (@jonas054)ConditionPosition regarding statement modifiers. (@bbatsov)dstr nodes. (@bbatsov)UselessAccessModifier not handling attr_* correctly. (@fshowalter)NegatedIf properly handles negated unless condition. (@bbatsov)NegatedWhile properly handles negated until condition. (@bbatsov)Syntax cop in output from --auto-gen-config. (@jonas054)SpaceAfterComma and other cops. (@jonas054)NilComparison. (@bbatsov)NonNilCheck. (@bbatsov)StringConversionInInterpolation. (@bbatsov)ClassMethods check only on class/module bodies. (@bbatsov)Blocks cop avoids auto-correction if it would introduce a semantic change. (@jonas054)NonNilCheck. (@bbatsov)GuardClause checks for conditionals that can be replaced by guard clauses. (@bbatsov)EmptyInterpolation checks for empty interpolation in double-quoted strings. (@bbatsov)LineEndConcatenation cop << aware. (@mockdeep)--fail-level changes minimum severity for exit with error code. (@hiroponz)--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)SpaceBeforeFirstArg checks for space between the method name and the first argument in method calls without parentheses. (@jonas054)SingleSpaceBeforeFirstArg checks that no more than one space is used between the method name and the first argument in method calls without parentheses. (@jonas054)disabled_lines displays cops and line ranges disabled by inline comments. (@fshowalter)UselessAccessModifiers checks for access modifiers that have no effect. (@fshowalter)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)NonNilCheck cop from NilComparison. (@bbatsov)FavorJoin to ArrayJoin. (@bbatsov)FavorUnlessOverNegatedIf to NegatedIf. (@bbatsov)FavorUntilOverNegatedWhileto NegatedWhile. (@bbatsov)HashMethods to DeprecatedHashMethods. (@bbatsov)ReadAttribute to ReadWriteAttribute and extended it to check for uses of write_attribute. (@bbatsov)BlockNesting not auto-generating correctly. (@tmorris-fiksu)LiteralInInterpolation. (@bbatsov)StringConversionInInterpolation. (@bbatsov)Include and Exclude paths in a .rubocop.yml are interpreted as relative to the directory of that file. (@jonas054)LiteralInInterpolation. (@bbatsov)rescue clauses in SignalException. (@bbatsov).rubocop.yml file. (@jonas054)LineEndConcatenation for % string literals. (@bbatsov)DeprecatedClassMethods (e.g. ::File.exists?). (@bbatsov)--only option now enables the given cop in case it is disabled in configuration. (@jonas054)vendor directories works. (@jonas054)SpaceAfterComma and SpaceInsideBrackets. (@hiroponz)HashSyntax when there is missing space around operator. (@jonas054)NumericLiterals. (@bbatsov)--auto-gen-config overwrite an existing rubocop-todo.yml file instead of asking the user to remove it. (@jonas054)_other as well as other in OpMethod. (@bbatsov)NumericLiterals so MinDigits is correct. (@tmorris-fiksu)RegexpLiteral so we don't generate illegal values for MaxSlashes. (@jonas054)Include param in the default config of the Rails cops. (@bbatsov)Rakefile, Gemfile and Capfile by default in the FileName cop. (@bbatsov)separator style hashes in IndentHash. (@jonas054)-vV, -v --show-cops). (@jkogara)LiteralInCondition when the condition is non-primitive array. (@bbatsov)FileName makes sure that source files have snake_case names. (@bbatsov)DeprecatedClassMethods checks for deprecated class methods. (@bbatsov)StringConversionInInterpolation checks for redundant Object#to_s in string interpolation. (@bbatsov)LiteralInInterpolation checks for interpolated string literals. (@bbatsov)SelfAssignment checks for places where the self-assignment shorthand should have been used. (@bbatsov)DoubleNegation checks for uses of !!. (@bbatsov)PercentLiteralDelimiters enforces consistent usage of %-literal delimiters. (@hannestyden)ActionFilter enforces the use of _filter or _action action filter methods. (@bbatsov)ScopeArgs makes sure you invoke the scope method properly. (@bbatsov)with_fixed_indentation style to AlignParameters cop. (@hannestyden)IgnoreLastArgumentHash option to AlignHash cop. (@hannestyden)SingleLineMethods cop does auto-correction. (@jonas054)Semicolon cop does auto-correction. (@jonas054)EmptyLineBetweenDefs cop does auto-correction. (@jonas054)IndentationWidth cop does auto-correction. (@jonas054)IndentationConsistency cop does auto-correction. (@jonas054)fuubar displays a progress bar and shows details of offenses as soon as they are detected. (@yujinakayama)IndentHash checks the indentation of the first key in multi-line hash literals. (@jonas054)IndentArray checks the indentation of the first element in multi-line array literals. (@jonas054)vendor/** by default. (@jeremyolliver)IfUnlessModifier and WhileUntilModifier supports MaxLineLength, which is independent of LineLength parameter Max. (@agrimm)ClassAndModuleChildren checks the style of children definitions at classes and modules: nested / compact. (@geniou)rubocop --format offences. (@ma2gedev)Ignore param from the Rails Output cop. The standard Exclude/Include should be used instead. (@bbatsov)FavorSprintf to FormatString and made it configurable. (@bbatsov)Offence to Offense. (@bbatsov)offense in all messages instead of offence. (@bbatsov)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)Style param of DotPosition cop to EnforcedStyle. (@bbatsov)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)MethodDefParentheses and other cops. (@jonas054)ParenthesesAroundCondition. (@bbatsov)begin..rescue..end with retry) in UselessAssignment. (@yujinakayama)EmptyLines. (@bbatsov)RangeError or "clobbering". (@jonas054)--auto-correct runs. (@jonas054)[Corrected] tag sometimes missing in output from --auto-correct runs. (@jonas054)EndAlignment cop when AlignWith is keyword. (@jonas054)case conditions in LiteralInCondition. (@bbatsov)DotPosition when enforced style is set to trailing. (@bbatsov)LineEndConcatenation. (@bbatsov)BracesAroundHashParameters and SpaceInsideHashLiteralBraces. (@jonas054)IndentationWidth auto-correction so it doesn't correct things that IndentationConsistency should correct. (@jonas054)RegexpLiteral concerning --auto-gen-config. (@jonas054)--show-cops that made it print the default configuration rather than the current configuration. (@jonas054)rubocop:disable comments with indentations were treated as multiline cop disabling comments. (@yujinakayama)rubocop:disable comments with a cop name including all (e.g. MethodCallParentheses) were disabling all cops. (@yujinakayama)# rubocop:disable were confused with real comments. (@yujinakayama)PercentLiteralDelimiters concerning auto-correct of regular expressions with interpolation. (@hannestyden)EmptyLinesAroundBody of empty line inside otherwise empty class/module/method that caused crash in auto-correct. (@jonas054)LineEndConcatenation. (@bbatsov)Documentation cop so that a comment followed by an empty line and then a class definition is not considered to be class documentation. (@jonas054)ParenthesesAroundCondition when the parentheses are actually required. (@bbatsov)AccessModifierIndentation. (@jonas054)%w arrays in TrailingComma. (@jonas054)AlignHash for single line hashes. (@jonas054)RequireParentheses checks for method calls without parentheses together with a boolean operator indicating that a mistake about precedence may have been made. (@jonas054)WordArray cop does auto-correction. (@jonas054)Proc cop does auto-correction. (@bbatsov)AccessModifierIndentation cop does auto-correction. (@jonas054)requires and options. (@nevir)EndLineConcatenation checks for string literal concatenation with + at line end. (@bbatsov)json requirement to >= 1.7.7. (@bbatsov)Include/Exclude supports relative globbing to some extent. (@nevir)TrailingComma. (@jonas054)ConditionPosition checks for misplaced conditions in expressions like if/unless/when/until. (@bbatsov)ElseLayout checks for odd arrangement of code in the else branch of a conditional expression. (@bbatsov)rubocop-todo.yml with comments about offence count, configuration parameters, and auto-correction support. (@jonas054)-D/--display-cop-names to trigger the display of cop names in offence messages. (@bbatsov)NumericLiterals cop does auto-correction. (@dblock)TrailingComma checks for comma after the last item in a hash, array, or method call parameter list. (@jonas054)AmbiguousOperator from Syntax cop. It checks for ambiguous operators in the first argument of a method invocation without parentheses. (@yujinakayama)AmbiguousRegexpLiteral from Syntax cop. It checks for ambiguous regexp literals in the first argument of a method invocation without parentheses. (@yujinakayama)UselessElseWithoutRescue from Syntax cop. It checks for useless else in begin..end without rescue. (@yujinakayama)InvalidCharacterLiteral from Syntax cop. It checks for invalid character literals with a non-escaped whitespace character (e.g. ? ). (@yujinakayama)Syntax cop from the configuration. It no longer can be disabled and it reports only invalid syntax offences. (@yujinakayama)rubocop --show-cops now looks like a YAML configuration file. The --show-cops option takes a comma separated list of cops as optional argument. (@jonas054)IndentationConsistency extracted from IndentationWidth, which has checked two kinds of offences until now. (@jonas054)EndAlignment has configuration AlignWith: variable, it now handles @@a = if ... and a, b = if .... (@jonas054)SpaceAroundOperators now reports an offence for @@a=0. (@jonas054)UselessAssignment. (@yujinakayama)Include or Exclude under each cop configuration) had run. (@yujinakayama)SpaceAfterColon. (@jonas054)--no-color option works again. (@jonas054)MethodDefParentheses. (@bbatsov).rubocop.yml file, and therefore get their configuration from RuboCop's config/default.yml, no longer get configuration from RuboCop's .rubocop.yml and rubocop-todo.yml. (@jonas054)EndAlignment now handles for example private def some_method, which is allowed in Ruby 2.1. It requires end to be aligned with private, not def, in such cases. (@jonas054)--auto-correct are now handled immediately and corrected when possible, so running --auto-correct once is enough. (@jonas054)EmptyLinesAroundBody and TrailingWhitespace resolved. (@jonas054)ParenthesesAroundCondition no longer crashes on parentheses around the condition in a ternary if. (@jonas054)StringLiterals. (@bbatsov)BracesAroundHashParameters cop does auto-correction. (@dblock)ParenthesesAroundCondition cop does auto-correction. (@dblock)EmptyLines cop does auto-correction. (@dblock)DefaultScope ensures default_scope is called properly with a block argument. (@bbatsov)Include param, which specifies the files on which they should operate. (@bbatsov)Exclude param, which specifies the files on which they should not operate. (@bbatsov)IndentationWidth cop now detects inconsistent indentation between lines that should have the same indentation. (@jonas054)EmptyLinesAroundBody cop does auto-correction. (@dblock)Alias cop does auto-correction. (@dblock)CaseIndentation cop is now configurable with parameters IndentWhenRelativeTo and IndentOneStep. (@jonas054)For cop is now configurable to enforce either each (default) or for. (@jonas054)EndAlignment cop is now configurable for alignment with keyword (default) or variable. (@jonas054)Severity param. (@codez)FlipFlop checks for flip flops. (@agrimm)MethodDefParentheses to allow for requiring either parentheses or no parentheses in method definitions. Replaces DefWithoutParentheses. (@skanev)Enabled: false) in rubocop-todo.yml by the --auto-gen-config option is now supported for some cops. (@jonas054)AccessorMethodName checks accessor method names for non-idiomatic names like get_attribute and set_attribute. (@bbatsov)PredicateName checks the names of predicate methods for non-idiomatic names like is_something, has_something, etc. (@bbatsov)SymbolNames as it was generating way too many false positives. (@bbatsov)ReduceArguments to SingleLineBlockParams and made it configurable. (@bbatsov)StringLiterals cop. (@bbatsov)SpaceAroundOperators to not report missing space around operator for def self.method *args. (@jonas054)['AllCops']['Includes'] and ['AllCops']['Excludes'] when passing config via -c. (@fancyremarker, @codez)DotPosition cop with trailing style for method calls on same line. (@vonTronje)RegexpLiteral cop. (@jonas054)each{ |x| to each d o |x|. (@jonas054)if /pattern/; end) in MultilineIfThen. (@agrimm)RedundantSelf. (@bbatsov)self.Foo in RedundantSelf cop. (@chulkilee)EndOfLine that occurs when default encoding is US_ASCII and an inspected file has non-ascii characters. (@jonas054)MethodDefParentheses when parentheses are required. (@skanev)Output checks for calls to print, puts, etc. in Rails. (@daviddavis)EmptyLinesAroundBody checks for empty lines around the bodies of class, method and module definitions. (@bbatsov)LeadingCommentSpace cop does auto-correction. (@jonas054)SpaceAfterControlKeyword cop does auto-correction. (@jonas054)SpaceAfterColon cop does auto-correction. (@jonas054)SpaceAfterComma cop does auto-correction. (@jonas054)SpaceAfterSemicolon cop does auto-correction. (@jonas054)SpaceAfterMethodName cop does auto-correction. (@jonas054)SpaceAroundBlockBraces cop does auto-correction. (@jonas054)SpaceAroundEqualsInParameterDefault cop does auto-correction. (@jonas054)SpaceAroundOperators cop does auto-correction. (@jonas054)SpaceBeforeModifierKeyword cop does auto-correction. (@jonas054)SpaceInsideHashLiteralBraces cop does auto-correction. (@jonas054)SpaceInsideBrackets cop does auto-correction. (@jonas054)SpaceInsideParens cop does auto-correction. (@jonas054)TrailingWhitespace cop does auto-correction. (@jonas054)TrailingBlankLines cop does auto-correction. (@jonas054)FinalNewline cop does auto-correction. (@jonas054)CyclomaticComplexity checks the cyclomatic complexity of methods against a configurable max value. (@jonas054)EnforcedStyleForEmptyBraces with values space and no_space (default) added to SpaceAroundBlockBraces. (@jonas054)MinSize added to WordArray to allow small string arrays, retaining the default (0). (@claco)AccessControl cop is now configurable with the EnforcedStyle option. (@sds)AccessControl cop to AccessModifierIndentation and EmptyLinesAroundAccessModifier. (@bbatsov)EnforcedStyleForEmptyBraces to SpaceInsideHashLiteralBraces cop, and change EnforcedStyleIsWithSpaces (values true, false) to EnforcedStyle (values space, no_space). (@jonas054)NumericLiterals cop. (@bbatsov)BracesAroundHashParameters cop. (@dblock)StringLiterals cop no longer reports errors for character literals such as ?/. That should be done only by the CharacterLiterals cop. (@jonas054)$GLOBAL_VAR from English library should no longer be inserted when auto-correcting short-form global variables like $!. (@nevir)MethodCallParentheses should allow methods starting with uppercase letter. (@bbatsov)UselessSetterCall. (@yujinakayama)EndOfLine cop is operational again. (@jonas054)if /pattern/; end) in FavorModifier. (@yujinakayama)RescueException no longer crashes when the namespace of a rescued class is in a local variable. (@jonas054)alias in the body of an instance_exec. (@bbatsov)WordArray. (@bbatsov)BracesAroundHashParameters checks for braces in function calls with hash parameters. (@dblock)SpaceAfterNot tracks redundant space after the ! operator. (@bbatsov)ClassLength counted lines of inner classes/modules. (@yujinakayama)Documentation. (@yujinakayama)RaiseArgs allows exception constructor calls with more than one 1 argument. (@bbatsov)MethodCalledOnDoEndBlock keeps track of methods called on do...end blocks.AllCops/RunRailsCops can be set to true for a project, removing the need to give the -R/--rails option with every invocation of rubocop.simple/clang/progress/emacs formatters now print [Corrected] along with offence message when the offence is automatically corrected.simple/clang/progress formatters now print count of auto-corrected offences in the final summary.json formatter now outputs corrected key with boolean value in offence objects whether the offence is automatically corrected.ClassLength checks for overly long class definitions.Debugger checks for forgotten calls to debugger or pry.RedundantException checks for code like raise RuntimeError, message.RaiseArgs checks the args passed to raise/fail.MethodAndVariableSnakeCase replaced by MethodName and VariableName, both having the configuration parameter EnforcedStyle with values snake_case (default) and camelCase.HashSyntax cop is now configurable and can enforce the use of the classic hash rockets syntax.StringLiterals cop is now configurable and can enforce either single-quoted or double-quoted strings.RedundantReturn to allow a return with multiple values.Semicolon to allow the use of ; as an expression separator.SignalException cop is now configurable and can enforce the semantic rule or an exclusive use of raise or fail.LambdaCall is now configurable and enforce either Proc#call or Proc#().EnforcedStyle to SpaceAroundBraces.NoSpaceBeforeBlockParameters to SpaceBeforeBlockParameters.AlignHash cop: single key/value pair when configuration is table for '=>' and separator for :.NumericLiterals.AlignParameters cop.Syntax offences with warning severity.AllCops/RunRailsCops configuration parameter in different directories.AndOr auto-correction.AlignParameters and AlignArray auto-correction to destroy code.RedundantReturn auto-correction to produce invalid code.!= expressions in EvenOdd cop.SignalException cop now finds raise calls anywhere, not only in begin sections.Blocks auto-correction to produce invalid code.HashSyntax cop does auto-correction.SpaceAroundBraces to SpaceAroundBlockBraces.SpaceAroundBlockBraces now has a NoSpaceBeforeBlockParameters config option to enforce a style for blocks with parameters like {|foo| puts }.LambdaCall tracks uses of the obscure lambda.(...) syntax.FinalNewline.UselessSetterCall.UselessComparison and NilComparison.AllowAdjacentOneLineDefs for EmptyLineBetweenDefs.MultilineBlockChain keeps track of chained blocks spanning multiple lines.RedundantSelf cop does auto-correction.AvoidPerlBackrefs cop does auto-correction.AvoidPerlisms cop does auto-correction.RedundantReturn cop does auto-correction.Blocks cop does auto-correction.TrailingBlankLines keeps track of extra blanks lines at the end of source file.AlignHash keeps track of bad alignment in multi-line hash literals.AlignArray keeps track of bad alignment in multi-line array literals.SpaceBeforeModifierKeyword keeps track of missing space before a modifier keyword (if, unless, while, until).FinalNewline keeps tracks of the required final newline in a source file.SpaceInsideHashLiteralBraces and SpaceAroundBraces cops.BlockAlignment cop now allows end to be aligned with the start of the line containing do.SymbolName now has an AllowDots config option to allow symbols like :'whatever.submit_button'.UselessAssignment cop to UselessSetterCall.UnusedLocalVariable cop into UselessAssignment.UselessAssignment cop now has advanced logic that tracks not only assignment at the end of the method but also every assignment in every scope.AvoidGlobalVars.AllowedVariables to AvoidGlobalVars to allow users to whitelist certain global variables.AvoidGlobalVars to GlobalVars.AvoidPerlisms to SpecialGlobalVars.AvoidFor to For.AvoidClassVars to ClassVars.AvoidPerlBackrefs to PerlBackrefs.NumericLiterals now accepts a config param MinDigits - the minimal number of digits in the integer portion of number for the cop to check it.do with WhileUntilDo auto-correction.UselessAssignment (formerly of UnusedLocalVariable) and ShadowingOuterLocalVariable (like clazz = Array; class SomeClass < clazz; end).reduce argument (ReduceArguments).--show-cops option to show available cops.NilComparison keeps track of comparisons like == nil.EvenOdd keeps track of occasions where Fixnum#even? or Fixnum#odd? should have been used (like x % 2 == 0).IndentationWidth checks for files using indentation that is not two spaces.SpaceAfterMethodName keeps track of method definitions with a space between the method name and the opening parenthesis.ParenthesesAsGroupedExpression keeps track of method calls with a space before the opening parenthesis.HashMethods keeps track of uses of deprecated Hash methods.HasAndBelongsToMany checks for uses of has_and_belongs_to_many.ReadAttribute tracks uses of read_attribute.Attr cop does auto-correction.CollectionMethods cop does auto-correction.SignalException cop does auto-correction.EmptyLiteral cop does auto-correction.MethodCallParentheses cop does auto-correction.DefWithParentheses cop does auto-correction.DefWithoutParentheses cop does auto-correction.-s/--silent option. Now progress/simple/clang formatters always report summary and emacs/files formatters no longer report.LineContinuation cop.ConstantName.Class.new/Module.new in AccessControl.UselessAssignment.ColonMethodCalls now allows constructor methods (like Nokogiri::HTML() to be called with double colon.LeadingCommentSpace offence reporting.AsciiComments offence reporting.BlockComments offence reporting.TrivialAccessors now ignores methods on user-configurable whitelist (such as to_s and to_hash).--auto-gen-config outputs RuboCop configuration that disables all cops that detect any offences.CommentAnnotation cop is now configurable.--debug mode.AlignParameters cop.UselessComparison checks for comparisons of the same arguments.UselessAssignment checks for useless assignments to local variables.SignalException checks for proper usage of fail and raise.ModuleFunction checks for usage of extend self in modules.begin-end-while, begin-end-until) in UnusedLocalVariable and ShadowingOuterLocalVariable.do-end would change the meaning of the code.RedundantSelf now allows self. followed by any ruby keyword.DotPosition cop handles correctly code like l.(1).CommentAnnotation cop allows keywords (e.g. Review, Optimize) if they just begin a sentence.EmptyLineBetweenDefs cop.AssignmentInCondition cop.SymbolName cop.AndOr cop only if it does not change the meaning of the code.StringLiterals string content check.RedundantReturn tracks redundant returns in method bodies.RedundantBegin tracks redundant begin blocks in method definitions.RedundantSelf tracks redundant uses of self.EmptyEnsure tracks empty ensure blocks.CommentAnnotation tracks formatting of annotation comments such as TODO.FileListFormatter outputs just a list of files with offences in them (related to #357).TrivialAccessors now has an ExactNameMatch config option (related to #308).TrivialAccessors now has an ExcludePredicates config option (related to #326).Parser::AST::Rewriter anymore. All 3rd party Cops should remove the call to super in their callbacks. If you implement your own processing you need to define the #investigate method instead of #inspect. Refer to the documentation of Cop::Commissioner and Cop::Cop classes for more information.EndAlignment cop split into EndAlignment and BlockAlignment cops.TrivialAccessors now detects class attributes as well as instance attributes.$SAFE to the list of built-in global variables.CharacterLiteral (%w(?)).ParenthesesAroundCondition.-l/--lint option to allow doing only linting with no style checks (similar to running ruby -wc).BlockAlignSchema configuration option from EndAlignment. We now support only the default alignment schema - StartOfAssignment.CollectionMethods configurable.DotPosition cop configurable - now both leading and trailing styles are supported.LiteralInCondition._ in ShadowingOuterLocalVariable.UnusedLocalVariable and ShadowingOuterLocalVariable when inspecting keyword splat argument.MultilineIfThen.EndAlignment.UnusedLocalVariable and ShadowingOuterLocalVariable when inspecting named captures.EnsureReturn throws an exception when ensure has no body.--format progress).--format json).--format clang). The clang formatter marks a whole range rather than just the starting position, to indicate more clearly where the problem is.-f/--format option to specify formatter.-o/--out option to specify output file for each formatter.-r/--require option to inject external Ruby code into RuboCop.-V/--verbose-version option that displays Parser version and Ruby version as well.-R/--rails option that enables extra Rails-specific cops.-a/--auto-correct.CaseEquality checks for explicit use of ===.AssignmentInCondition checks for assignment in conditions.EndAlignment tracks misaligned end keywords.Void tracks uses of literals/variables/operators in possibly void context.Documentation checks for top level class/module doc comments.UnreachableCode tracks unreachable code segments.MethodCallParentheses tracks unwanted braces in method calls.UnusedLocalVariable tracks unused local variables for each scope.ShadowingOuterLocalVariable tracks use of the same name as outer local variables for block arguments or block local variables.WhileUntilDo tracks uses of do with multi-line while/until.CharacterLiteral tracks uses of character literals (?x).EndInMethod tracks uses of END in method definitions.LiteralInCondition tracks uses of literals in the conditions of if/while/until.BeginBlock tracks uses of BEGIN blocks.EndBlock tracks uses of END blocks.DotPosition tracks the dot position in multi-line method calls.Attr tracks uses of Module#attr.-a/--auto-correct.-e/--emacs option. (Use --format emacs instead).progress formatter the default.progress, simple and clang) now print relative file paths if the paths are under the current working directory.RuboCop::Cop::Lint is for cops that emit warnings. RuboCop::Cop::Style is for cops that do not belong in other namespaces.FavorPercentR and PercentR into one cop called RegexpLiteral, and add configuration parameter MaxSlashes.CountKeywordArgs configuration option to ParameterLists cop.[?\r, ?\n].BlockNesting checks for excessive block nesting.MultilineIfThen cop that occurred in some special cases.Proc tracks uses of Proc.new.NewLambdaLiteral to Lambda.Lambda cop more closely to the style guide - it now allows the use of lambda for multi-line blocks.initialize method looking like a trivial writer.if/unless/while/until issues.ArrayLiteral and HashLiteral into EmptyLiteral cop.ParameterLists accepts in now configurable.SymbolSnakeCase into SymbolName, which has an option AllowCamelCase enabled by default.Ripper to the portable Parser.ConstantName checks for constant which are not using SCREAMING_SNAKE_CASE.AccessControl checks private/protected indentation and surrounding blank lines.Loop checks for begin/end/while(until) and suggests the use of Kernel#loop.OpMethod now handles definition of unary operators without crashing.SymbolSnakeCase now handles aliasing of operators without crashing.RescueException now handles the splat operator * in a rescue clause without crashing..rubocop.yml..rubocop.yml, can now include configuration from other files through the inherit_from directive. All configuration files implicitly inherit from config/default.yml.ClassMethods checks for uses for class/module names in definitions of class/module methods.SingleLineMethods checks for methods implemented on a single line.FavorJoin checks for usages of Array#* with a string argument.BlockComments tracks uses of block comments(=begin/=end comments).EmptyLines tracks consecutive blank lines.WordArray tracks arrays of words.SpaceInsideHashLiteralBraces checks for spaces inside hash literal braces - style is configurable.LineContinuation tracks uses of the line continuation character (\).SymbolArray tracks arrays of symbols.TrivialAccessors tracks method definitions that could be automatically generated with attr_* methods.LeadingCommentSpace checks for missing space after # in comments.ColonMethodCall tracks uses of :: for method calls.AvoidGlobalVars tracks uses of non built-in global variables.SpaceAfterControlKeyword tracks missing spaces after if/elsif/case/when/until/unless/while.Not tracks uses of the not keyword.Eval tracks uses of the eval function.SpaceAroundEqualsInParameterDefault doesn't work properly with empty string.BraceAfterPercent for %W, %i and %I and added more tests.Alias cop. :alias is no longer treated as keyword.ArrayLiteral now properly detects Array.new.HashLiteral now properly detects Hash.new.VariableInterpolation now detects regexp back references and doesn't crash..rubocop.yml.Indentation cop to CaseIndentation to avoid confusion.EmptyLines cop to EmptyLineBetweenDefs to avoid confusion.AsciiIdentifiersAndComments cop in two separate cops.super.whitespace?': undefined method.OpMethod cop doesn't work if method arg is not in braces.SymbolSnakeCase now tracks Ruby 1.9 hash labels as well as regular symbols.Term::ANSIColor with Rainbow.-d/--debug is passed.ReduceArguments tracks argument names in reduce calls.MethodLength tracks number of LOC (lines of code) in methods.RescueModifier tracks uses of rescue in modifier form.PercentLiterals tracks uses of %q, %Q, %s and %x.BraceAfterPercent tracks uses of % literals with delimiters other than ().EnsureReturn tracks usages of return in ensure blocks.HandleExceptions tracks suppressed exceptions.AsciiIdentifiersAndComments tracks uses of non-ascii characters in identifiers and comments.RescueException tracks uses of rescuing the Exception class.ArrayLiteral tracks uses of Array.new.HashLiteral tracks uses of Hash.new.OpMethod tracks the argument name in operator methods.PercentR tracks uses of %r literals with zero or one slash in the regexp.FavorPercentR tracks uses of // literals with more than one slash in the regexp.:==, :<=> and the like to snake_case.alias with bareword arguments.FavorSprintf that checks for usages of String#%.Semicolon that checks for usages of ; as expression separator.VariableInterpolation that checks for variable interpolation in double quoted strings.Alias that checks for uses of the keyword alias.