Kat's Preferred RuboCop Style Guide
Documentation: | |
Enabled: false | |
AllCops: | |
Include: | |
- '**/Rakefile' | |
- '**/config.ru' | |
Exclude: | |
- 'db/**/*' | |
- 'test/test_helper.rb' | |
- 'spec/spec_helper.rb' | |
- 'spec/rails_helper.rb' | |
- 'spec/support/accepts_nested_attributes.rb' | |
- 'spec/support/deferred_garbage_collection.rb' | |
- 'spec/support/api_helpers.rb' | |
- 'config/**/*' | |
##################### Style ################################## | |
# Check indentation of private/protected visibility modifiers. | |
Style/AccessModifierIndentation: | |
Enabled: true | |
# Check the naming of accessor methods for get_/set_. | |
Style/AccessorMethodName: | |
Enabled: true | |
# Use alias_method instead of alias. | |
Style/Alias: | |
EnforcedStyle: prefer_alias_method | |
Enabled: true | |
# Align the elements of an array literal if they span more than one line. | |
Style/AlignArray: | |
Enabled: true | |
# Align the elements of a hash literal if they span more than one line. | |
Style/AlignHash: | |
Enabled: true | |
# Align the parameters of a method call if they span more than one line. | |
Style/AlignParameters: | |
Enabled: true | |
# Use &&/|| instead of and/or. | |
Style/AndOr: | |
Enabled: false | |
# Use `Array#join` instead of `Array#*`. | |
Style/ArrayJoin: | |
Enabled: true | |
# Use only ascii symbols in comments. | |
Style/AsciiComments: | |
Enabled: true | |
# Use only ascii symbols in identifiers. | |
Style/AsciiIdentifiers: | |
Enabled: true | |
# Checks for uses of Module#attr. | |
Style/Attr: | |
Enabled: true | |
# Avoid the use of BEGIN blocks. | |
Style/BeginBlock: | |
Enabled: true | |
# Checks if usage of %() or %Q() matches configuration. | |
Style/BarePercentLiterals: | |
Enabled: false | |
# Do not use block comments. | |
Style/BlockComments: | |
Enabled: true | |
# Put end statement of multiline block on its own line. | |
Style/BlockEndNewline: | |
Enabled: true | |
# Avoid using {...} for multi-line blocks (multiline chaining is # always | |
# ugly). Prefer {...} over do...end for single-line blocks. | |
Style/BlockDelimiters: | |
Enabled: true | |
# Enforce braces style around hash parameters. | |
Style/BracesAroundHashParameters: | |
Enabled: false | |
# Avoid explicit use of the case equality operator(===). | |
Style/CaseEquality: | |
Enabled: false | |
# Indentation of when in a case/when/[else/]end. | |
Style/CaseIndentation: | |
Enabled: true | |
# Checks for uses of character literals. | |
Style/CharacterLiteral: | |
Enabled: true | |
# Use CamelCase for classes and modules.' | |
Style/ClassAndModuleCamelCase: | |
Enabled: true | |
# Checks style of children classes and modules. | |
Style/ClassAndModuleChildren: | |
Enabled: false | |
# Enforces consistent use of `Object#is_a?` or `Object#kind_of?`. | |
Style/ClassCheck: | |
Enabled: false | |
# Use self when defining module/class methods. | |
Style/ClassMethods: | |
Enabled: true | |
# Avoid the use of class variables. | |
Style/ClassVars: | |
Enabled: true | |
# Do not use :: for method call. | |
Style/ColonMethodCall: | |
Enabled: true | |
# Checks formatting of special comments (TODO, FIXME, OPTIMIZE, HACK, REVIEW). | |
Style/CommentAnnotation: | |
Enabled: false | |
# Indentation of comments. | |
Style/CommentIndentation: | |
Enabled: true | |
# Use the return value of `if` and `case` statements for assignment to a | |
# variable and variable comparison instead of assigning that variable | |
# inside of each branch. | |
Style/ConditionalAssignment: | |
Enabled: false | |
# Constants should use SCREAMING_SNAKE_CASE. | |
Style/ConstantName: | |
Enabled: true | |
# Use def with parentheses when there are arguments. | |
Style/DefWithParentheses: | |
Enabled: true | |
# Checks for use of deprecated Hash methods. | |
Style/DeprecatedHashMethods: | |
Enabled: true | |
# Document classes and non-namespace modules. | |
Style/Documentation: | |
Enabled: true | |
# Checks the position of the dot in multi-line method calls. | |
Style/DotPosition: | |
Enabled: false | |
# Checks for uses of double negation (!!). | |
Style/DoubleNegation: | |
Enabled: false | |
# Prefer `each_with_object` over `inject` or `reduce`. | |
Style/EachWithObject: | |
Enabled: false | |
# Align elses and elsifs correctly. | |
Style/ElseAlignment: | |
Enabled: true | |
# Avoid empty else-clauses. | |
Style/EmptyElse: | |
Enabled: true | |
# Use empty lines between defs. | |
Style/EmptyLineBetweenDefs: | |
Enabled: false | |
# Don't use several empty lines in a row. | |
Style/EmptyLines: | |
Enabled: true | |
# Keep blank lines around access modifiers. | |
Style/EmptyLinesAroundAccessModifier: | |
Enabled: true | |
# Keeps track of empty lines around block bodies. | |
Style/EmptyLinesAroundBlockBody: | |
Enabled: true | |
# Keeps track of empty lines around class bodies. | |
Style/EmptyLinesAroundClassBody: | |
Enabled: true | |
# Keeps track of empty lines around module bodies. | |
Style/EmptyLinesAroundModuleBody: | |
Enabled: true | |
# Keeps track of empty lines around method bodies. | |
Style/EmptyLinesAroundMethodBody: | |
Enabled: true | |
# Prefer literals to Array.new/Hash.new/String.new. | |
Style/EmptyLiteral: | |
Enabled: true | |
# Avoid the use of END blocks. | |
Style/EndBlock: | |
Enabled: true | |
# Use Unix-style line endings. | |
Style/EndOfLine: | |
Enabled: true | |
# Favor the use of Fixnum#even? && Fixnum#odd? | |
Style/EvenOdd: | |
Enabled: true | |
# Do not use unnecessary spacing. | |
Style/ExtraSpacing: | |
Enabled: true | |
# Use snake_case for source file names. | |
Style/FileName: | |
Enabled: true | |
# Checks for a line break before the first parameter in a multi-line method | |
# parameter definition. | |
Style/FirstMethodParameterLineBreak: | |
Enabled: true | |
# Checks for flip flops. | |
Style/FlipFlop: | |
Enabled: true | |
# Checks use of for or each in multiline loops. | |
Style/For: | |
Enabled: true | |
# Enforce the use of Kernel#sprintf, Kernel#format or String#%. | |
Style/FormatString: | |
Enabled: false | |
# Do not introduce global variables. | |
Style/GlobalVars: | |
Enabled: true | |
# Check for conditionals that can be replaced with guard clauses. | |
Style/GuardClause: | |
Enabled: true | |
# Prefer Ruby 1.9 hash syntax `{ a: 1, b: 2 }` | |
# over 1.8 syntax `{ :a => 1, :b => 2 }`. | |
Style/HashSyntax: | |
Enabled: true | |
# Finds if nodes inside else, which can be converted to elsif. | |
Style/IfInsideElse: | |
Enabled: true | |
# Favor modifier if/unless usage when you have a single-line body. | |
Style/IfUnlessModifier: | |
Enabled: false | |
# Do not use if x; .... Use the ternary operator instead. | |
Style/IfWithSemicolon: | |
Enabled: true | |
# Checks that conditional statements do not have an identical line at the | |
# end of each branch, which can validly be moved out of the conditional. | |
Style/IdenticalConditionalBranches: | |
Enabled: true | |
# Checks the indentation of the first line of the right-hand-side of a | |
# multi-line assignment. | |
Style/IndentAssignment: | |
Enabled: true | |
# Keep indentation straight. | |
Style/IndentationConsistency: | |
Enabled: true | |
# Use 2 spaces for indentation. | |
Style/IndentationWidth: | |
Enabled: true | |
# Checks the indentation of the first element in an array literal. | |
Style/IndentArray: | |
Enabled: false | |
# Checks the indentation of the first key in a hash literal. | |
Style/IndentHash: | |
Enabled: false | |
# Use Kernel#loop for infinite loops. | |
Style/InfiniteLoop: | |
Enabled: true | |
# Use the new lambda literal syntax for single-line blocks. | |
Style/Lambda: | |
Enabled: false | |
# Use lambda.call(...) instead of lambda.(...). | |
Style/LambdaCall: | |
Enabled: true | |
# Comments should start with a space. | |
Style/LeadingCommentSpace: | |
Enabled: true | |
# Use \ instead of + or << to concatenate two string literals at line end. | |
Style/LineEndConcatenation: | |
Enabled: false | |
# Do not use parentheses for method calls with no arguments. | |
Style/MethodCallParentheses: | |
Enabled: false | |
# Checks if the method definitions have or don't have parentheses. | |
Style/MethodDefParentheses: | |
Enabled: true | |
# Use the configured style when naming methods. | |
Style/MethodName: | |
Enabled: true | |
# Checks for usage of `extend self` in modules. | |
Style/ModuleFunction: | |
Enabled: false | |
# Checks that the closing brace in an array literal is either on the same line | |
# as the last array element, or a new line. | |
Style/MultilineArrayBraceLayout: | |
Enabled: false | |
EnforcedStyle: symmetrical | |
# Avoid multi-line chains of blocks. | |
Style/MultilineBlockChain: | |
Enabled: true | |
# Ensures newlines after multiline block do statements. | |
Style/MultilineBlockLayout: | |
Enabled: true | |
# Checks that the closing brace in a hash literal is either on the same line as | |
# the last hash element, or a new line. | |
Style/MultilineHashBraceLayout: | |
Enabled: false | |
EnforcedStyle: symmetrical | |
# Do not use then for multi-line if/unless. | |
Style/MultilineIfThen: | |
Enabled: true | |
# Checks that the closing brace in a method call is either on the same line as | |
# the last method argument, or a new line. | |
Style/MultilineMethodCallBraceLayout: | |
Enabled: false | |
EnforcedStyle: symmetrical | |
# Checks indentation of method calls with the dot operator that span more than | |
# one line. | |
Style/MultilineMethodCallIndentation: | |
Enabled: false | |
# Checks that the closing brace in a method definition is symmetrical with | |
# respect to the opening brace and the method parameters. | |
Style/MultilineMethodDefinitionBraceLayout: | |
Enabled: false | |
# Checks indentation of binary operations that span more than one line. | |
Style/MultilineOperationIndentation: | |
Enabled: false | |
# Avoid multi-line `? :` (the ternary operator), use if/unless instead. | |
Style/MultilineTernaryOperator: | |
Enabled: false | |
# Do not assign mutable objects to constants. | |
Style/MutableConstant: | |
Enabled: false | |
# Favor unless over if for negative conditions (or control flow or). | |
Style/NegatedIf: | |
Enabled: true | |
# Favor until over while for negative conditions. | |
Style/NegatedWhile: | |
Enabled: false | |
# Avoid using nested modifiers. | |
Style/NestedModifier: | |
Enabled: true | |
# Parenthesize method calls which are nested inside the argument list of | |
# another parenthesized method call. | |
Style/NestedParenthesizedCalls: | |
Enabled: false | |
# Use one expression per branch in a ternary operator. | |
Style/NestedTernaryOperator: | |
Enabled: true | |
# Use `next` to skip iteration instead of a condition at the end. | |
Style/Next: | |
Enabled: false | |
# Prefer x.nil? to x == nil. | |
Style/NilComparison: | |
Enabled: true | |
# Checks for redundant nil checks. | |
Style/NonNilCheck: | |
Enabled: true | |
# Use ! instead of not. | |
Style/Not: | |
Enabled: true | |
# Add underscores to large numeric literals to improve their readability. | |
Style/NumericLiterals: | |
Enabled: true | |
# Favor the ternary operator(?:) over if/then/else/end constructs. | |
Style/OneLineConditional: | |
Enabled: true | |
# When defining binary operators, name the argument other. | |
Style/OpMethod: | |
Enabled: true | |
# Check for simple usages of parallel assignment. It will only warn when | |
# the number of variables matches on both sides of the assignment. | |
Style/ParallelAssignment: | |
Enabled: false | |
# Don't use parentheses around the condition of an if/unless/while. | |
Style/ParenthesesAroundCondition: | |
Enabled: true | |
# Use `%`-literal delimiters consistently. | |
Style/PercentLiteralDelimiters: | |
Enabled: false | |
# Checks if uses of %Q/%q match the configured preference. | |
Style/PercentQLiterals: | |
Enabled: false | |
# Avoid Perl-style regex back references. | |
Style/PerlBackrefs: | |
Enabled: false | |
# Check the names of predicate methods. | |
Style/PredicateName: | |
Enabled: false | |
# Use proc instead of Proc.new. | |
Style/Proc: | |
Enabled: false | |
# Checks the arguments passed to raise/fail. | |
Style/RaiseArgs: | |
Enabled: false | |
# Don't use begin blocks when they are not needed. | |
Style/RedundantBegin: | |
Enabled: false | |
# Checks for an obsolete RuntimeException argument in raise/fail. | |
Style/RedundantException: | |
Enabled: false | |
# Checks usages of Object#freeze on immutable objects. | |
Style/RedundantFreeze: | |
Enabled: false | |
# Checks for parentheses that seem not to serve any purpose. | |
Style/RedundantParentheses: | |
Enabled: true | |
# Don't use return where it's not required. | |
Style/RedundantReturn: | |
Enabled: true | |
# Don't use self where it's not needed. | |
Style/RedundantSelf: | |
Enabled: false | |
# Use %r for regular expressions matching more than `MaxSlashes` '/' | |
# characters. Use %r only for regular expressions matching more | |
# than `MaxSlashes` '/' character. | |
Style/RegexpLiteral: | |
Enabled: false | |
# Avoid using rescue in its modifier form. | |
Style/RescueModifier: | |
Enabled: false | |
# Checks for places where self-assignment shorthand should have been used. | |
Style/SelfAssignment: | |
Enabled: false | |
# Don't use semicolons to terminate expressions. | |
Style/Semicolon: | |
Enabled: true | |
# Checks for proper usage of fail and raise. | |
Style/SignalException: | |
EnforcedStyle: only_fail | |
Enabled: true | |
# Enforces the names of some block params. | |
Style/SingleLineBlockParams: | |
Enabled: false | |
# Avoid single-line methods. | |
Style/SingleLineMethods: | |
Enabled: false | |
# Use spaces after colons. | |
Style/SpaceAfterColon: | |
Enabled: true | |
# Use spaces after commas. | |
Style/SpaceAfterComma: | |
Enabled: true | |
# Do not put a space between a method name and the opening parenthesis in a | |
# method definition. | |
Style/SpaceAfterMethodName: | |
Enabled: true | |
# Tracks redundant space after the ! operator. | |
Style/SpaceAfterNot: | |
Enabled: true | |
# Use spaces after semicolons. | |
Style/SpaceAfterSemicolon: | |
Enabled: true | |
# Checks that the equals signs in parameter default assignments have or don't | |
# have surrounding space depending on configuration. | |
Style/SpaceAroundEqualsInParameterDefault: | |
Enabled: false | |
# Use a space around keywords if appropriate. | |
Style/SpaceAroundKeyword: | |
Enabled: true | |
# Use a single space around operators. | |
Style/SpaceAroundOperators: | |
Enabled: true | |
# Checks that the left block brace has or doesn't have space before it. | |
Style/SpaceBeforeBlockBraces: | |
Enabled: false | |
# No spaces before commas. | |
Style/SpaceBeforeComma: | |
Enabled: true | |
# Checks for missing space between code and a comment on the same line. | |
Style/SpaceBeforeComment: | |
Enabled: true | |
# Checks that exactly one space is used between a method name and the first | |
# argument for method calls without parentheses. | |
Style/SpaceBeforeFirstArg: | |
Enabled: false | |
# No spaces before semicolons. | |
Style/SpaceBeforeSemicolon: | |
Enabled: true | |
# Checks that block braces have or don't have surrounding space. | |
# For blocks taking parameters, checks that the left brace has or doesn't | |
# have trailing space. | |
Style/SpaceInsideBlockBraces: | |
Enabled: false | |
# No spaces after [ or before ]. | |
Style/SpaceInsideBrackets: | |
Enabled: false | |
# Use spaces inside hash literal braces - or don't. | |
Style/SpaceInsideHashLiteralBraces: | |
Enabled: true | |
# No spaces after ( or before ). | |
Style/SpaceInsideParens: | |
Enabled: false | |
# No spaces inside range literals. | |
Style/SpaceInsideRangeLiteral: | |
Enabled: true | |
# Checks for padding/surrounding spaces inside string interpolation. | |
Style/SpaceInsideStringInterpolation: | |
EnforcedStyle: no_space | |
Enabled: true | |
# Avoid Perl-style global variables. | |
Style/SpecialGlobalVars: | |
Enabled: false | |
# Check for the usage of parentheses around stabby lambda arguments. | |
Style/StabbyLambdaParentheses: | |
EnforcedStyle: require_parentheses | |
Enabled: true | |
# Checks if uses of quotes match the configured preference. | |
Style/StringLiterals: | |
Enabled: true | |
# Checks if uses of quotes inside expressions in interpolated strings match the | |
# configured preference. | |
Style/StringLiteralsInInterpolation: | |
Enabled: true | |
# Checks if configured preferred methods are used over non-preferred. | |
Style/StringMethods: | |
PreferredMethods: | |
intern: to_sym | |
Enabled: true | |
# Use %i or %I for arrays of symbols. | |
Style/SymbolArray: | |
Enabled: false | |
# Use symbols as procs instead of blocks when possible. | |
Style/SymbolProc: | |
Enabled: false | |
# No hard tabs. | |
Style/Tab: | |
Enabled: true | |
# Checks trailing blank lines and final newline. | |
Style/TrailingBlankLines: | |
Enabled: true | |
# Checks for trailing comma in array and hash literals. | |
Style/TrailingCommaInLiteral: | |
Enabled: false | |
# Checks for trailing comma in argument lists. | |
Style/TrailingCommaInArguments: | |
Enabled: false | |
# Avoid trailing whitespace. | |
Style/TrailingWhitespace: | |
Enabled: true | |
# Checks for the usage of unneeded trailing underscores at the end of | |
# parallel variable assignment. | |
Style/TrailingUnderscoreVariable: | |
Enabled: true | |
# Prefer attr_* methods to trivial readers/writers. | |
Style/TrivialAccessors: | |
Enabled: false | |
# Do not use unless with else. Rewrite these with the positive case first. | |
Style/UnlessElse: | |
Enabled: false | |
# Checks for %W when interpolation is not needed. | |
Style/UnneededCapitalW: | |
Enabled: true | |
# TODO: Enable UnneededInterpolation Cop. | |
# Checks for strings that are just an interpolated expression. | |
Style/UnneededInterpolation: | |
Enabled: false | |
# Checks for %q/%Q when single quotes or double quotes would do. | |
Style/UnneededPercentQ: | |
Enabled: true | |
# Don't interpolate global, instance and class variables directly in strings. | |
Style/VariableInterpolation: | |
Enabled: true | |
# Use the configured style when naming variables. | |
Style/VariableName: | |
EnforcedStyle: snake_case | |
Enabled: true | |
# Use when x then ... for one-line cases. | |
Style/WhenThen: | |
Enabled: true | |
# Checks for redundant do after while or until. | |
Style/WhileUntilDo: | |
Enabled: true | |
# Favor modifier while/until usage when you have a single-line body. | |
Style/WhileUntilModifier: | |
Enabled: true | |
# Use %w or %W for arrays of words. | |
Style/WordArray: | |
Enabled: false | |
# TODO: Enable ZeroLengthPredicate Cop. | |
# Use #empty? when testing for objects of length 0. | |
Style/ZeroLengthPredicate: | |
Enabled: false | |
#################### Metrics ################################ | |
# A calculated magnitude based on number of assignments, | |
# branches, and conditions. | |
Metrics/AbcSize: | |
Enabled: true | |
Max: 60 | |
# Avoid excessive block nesting. | |
Metrics/BlockNesting: | |
Enabled: true | |
Max: 4 | |
# Avoid classes longer than 100 lines of code. | |
Metrics/ClassLength: | |
Enabled: true | |
# A complexity metric that is strongly correlated to the number | |
# of test cases needed to validate a method. | |
Metrics/CyclomaticComplexity: | |
Enabled: true | |
Max: 17 | |
# Limit lines to 80 characters. | |
Metrics/LineLength: | |
Enabled: true | |
Max: 120 | |
# Avoid methods longer than 10 lines of code. | |
Metrics/MethodLength: | |
Enabled: false | |
# Avoid modules longer than 100 lines of code. | |
Metrics/ModuleLength: | |
Enabled: false | |
# Avoid parameter lists longer than three or four parameters. | |
Metrics/ParameterLists: | |
Enabled: true | |
Max: 8 | |
# A complexity metric geared towards measuring complexity for a human reader. | |
Metrics/PerceivedComplexity: | |
Enabled: true | |
Max: 18 | |
#################### Lint ################################ | |
# Checks for ambiguous operators in the first argument of a method invocation | |
# without parentheses. | |
Lint/AmbiguousOperator: | |
Enabled: true | |
# Checks for ambiguous regexp literals in the first argument of a method | |
# invocation without parentheses. | |
Lint/AmbiguousRegexpLiteral: | |
Enabled: false | |
# Don't use assignment in conditions. | |
Lint/AssignmentInCondition: | |
Enabled: false | |
# Align block ends correctly. | |
Lint/BlockAlignment: | |
Enabled: true | |
# Default values in optional keyword arguments and optional ordinal arguments | |
# should not refer back to the name of the argument. | |
Lint/CircularArgumentReference: | |
Enabled: true | |
# Checks for condition placed in a confusing position relative to the keyword. | |
Lint/ConditionPosition: | |
Enabled: true | |
# Check for debugger calls. | |
Lint/Debugger: | |
Enabled: true | |
# Align ends corresponding to defs correctly. | |
Lint/DefEndAlignment: | |
Enabled: true | |
# Check for deprecated class method calls. | |
Lint/DeprecatedClassMethods: | |
Enabled: true | |
# Check for duplicate method definitions. | |
Lint/DuplicateMethods: | |
Enabled: false | |
# Check for duplicate keys in hash literals. | |
Lint/DuplicatedKey: | |
Enabled: false | |
# Check for immutable argument given to each_with_object. | |
Lint/EachWithObjectArgument: | |
Enabled: true | |
# Check for odd code arrangement in an else block. | |
Lint/ElseLayout: | |
Enabled: true | |
# Checks for empty ensure block. | |
Lint/EmptyEnsure: | |
Enabled: true | |
# Checks for empty string interpolation. | |
Lint/EmptyInterpolation: | |
Enabled: false | |
# Align ends correctly. | |
Lint/EndAlignment: | |
Enabled: true | |
# END blocks should not be placed inside method definitions. | |
Lint/EndInMethod: | |
Enabled: true | |
# Do not use return in an ensure block. | |
Lint/EnsureReturn: | |
Enabled: true | |
# The use of eval represents a serious security risk. | |
Lint/Eval: | |
Enabled: true | |
# Catches floating-point literals too large or small for Ruby to represent. | |
Lint/FloatOutOfRange: | |
Enabled: true | |
# The number of parameters to format/sprint must match the fields. | |
Lint/FormatParameterMismatch: | |
Enabled: true | |
# Don't suppress exception. | |
Lint/HandleExceptions: | |
Enabled: false | |
# Checks for adjacent string literals on the same line, which could better be | |
# represented as a single string literal. | |
Lint/ImplicitStringConcatenation: | |
Enabled: true | |
# TODO: Enable IneffectiveAccessModifier Cop. | |
# Checks for attempts to use `private` or `protected` to set the visibility | |
# of a class method, which does not work. | |
Lint/IneffectiveAccessModifier: | |
Enabled: false | |
# Checks for invalid character literals with a non-escaped whitespace | |
# character. | |
Lint/InvalidCharacterLiteral: | |
Enabled: true | |
# Checks of literals used in conditions. | |
Lint/LiteralInCondition: | |
Enabled: true | |
# Checks for literals used in interpolation. | |
Lint/LiteralInInterpolation: | |
Enabled: true | |
# Use Kernel#loop with break rather than begin/end/until or begin/end/while | |
# for post-loop tests. | |
Lint/Loop: | |
Enabled: false | |
# Do not use nested method definitions. | |
Lint/NestedMethodDefinition: | |
Enabled: true | |
# Do not omit the accumulator when calling `next` in a `reduce`/`inject` block. | |
Lint/NextWithoutAccumulator: | |
Enabled: true | |
# Checks for method calls with a space before the opening parenthesis. | |
Lint/ParenthesesAsGroupedExpression: | |
Enabled: true | |
# Checks for `rand(1)` calls. Such calls always return `0` and most likely | |
# a mistake. | |
Lint/RandOne: | |
Enabled: true | |
# Use parentheses in the method call to avoid confusion about precedence. | |
Lint/RequireParentheses: | |
Enabled: true | |
# Avoid rescuing the Exception class. | |
Lint/RescueException: | |
Enabled: true | |
# Do not use the same name as outer local variable for block arguments | |
# or block local variables. | |
Lint/ShadowingOuterLocalVariable: | |
Enabled: false | |
# 'Checks for Object#to_s usage in string interpolation. | |
Lint/StringConversionInInterpolation: | |
Enabled: false | |
# Do not use prefix `_` for a variable that is used. | |
Lint/UnderscorePrefixedVariableName: | |
Enabled: true | |
# Checks for rubocop:disable comments that can be removed. | |
# Note: this cop is not disabled when disabling all cops. | |
# It must be explicitly disabled. | |
Lint/UnneededDisable: | |
Enabled: false | |
# Checks for unused block arguments. | |
Lint/UnusedBlockArgument: | |
Enabled: false | |
# Checks for unused method arguments. | |
Lint/UnusedMethodArgument: | |
Enabled: false | |
# Unreachable code. | |
Lint/UnreachableCode: | |
Enabled: true | |
# Checks for useless access modifiers. | |
Lint/UselessAccessModifier: | |
Enabled: false | |
# Checks for useless assignment to a local variable. | |
Lint/UselessAssignment: | |
Enabled: true | |
# Checks for comparison of something with itself. | |
Lint/UselessComparison: | |
Enabled: true | |
# Checks for useless `else` in `begin..end` without `rescue`. | |
Lint/UselessElseWithoutRescue: | |
Enabled: true | |
# Checks for useless setter call to a local variable. | |
Lint/UselessSetterCall: | |
Enabled: true | |
# Possible use of operator/literal/variable in void context. | |
Lint/Void: | |
Enabled: true | |
##################### Performance ############################ | |
# Use `casecmp` rather than `downcase ==`. | |
Performance/Casecmp: | |
Enabled: true | |
# Use `str.{start,end}_with?(x, ..., y, ...)` instead of | |
# `str.{start,end}_with?(x, ...) || str.{start,end}_with?(y, ...)`. | |
Performance/DoubleStartEndWith: | |
Enabled: true | |
# TODO: Enable EndWith Cop. | |
# Use `end_with?` instead of a regex match anchored to the end of a string. | |
Performance/EndWith: | |
Enabled: false | |
# Use `strip` instead of `lstrip.rstrip`. | |
Performance/LstripRstrip: | |
Enabled: true | |
# Use `Range#cover?` instead of `Range#include?`. | |
Performance/RangeInclude: | |
Enabled: true | |
# TODO: Enable RedundantBlockCall Cop. | |
# Use `yield` instead of `block.call`. | |
Performance/RedundantBlockCall: | |
Enabled: false | |
# TODO: Enable RedundantMatch Cop. | |
# Use `=~` instead of `String#match` or `Regexp#match` in a context where the | |
# returned `MatchData` is not needed. | |
Performance/RedundantMatch: | |
Enabled: false | |
# TODO: Enable RedundantMerge Cop. | |
# Use `Hash#[]=`, rather than `Hash#merge!` with a single key-value pair. | |
Performance/RedundantMerge: | |
# Max number of key-value pairs to consider an offense | |
MaxKeyValuePairs: 2 | |
Enabled: false | |
# Use `sort` instead of `sort_by { |x| x }`. | |
Performance/RedundantSortBy: | |
Enabled: true | |
# Use `start_with?` instead of a regex match anchored to the beginning of a | |
# string. | |
Performance/StartWith: | |
Enabled: true | |
# Use `tr` instead of `gsub` when you are replacing the same number of | |
# characters. Use `delete` instead of `gsub` when you are deleting | |
# characters. | |
Performance/StringReplacement: | |
Enabled: true | |
# Checks for `.times.map` calls. | |
Performance/TimesMap: | |
Enabled: true | |
##################### Rails ################################## | |
# Enables Rails cops. | |
Rails: | |
Enabled: true | |
# Enforces consistent use of action filter methods. | |
Rails/ActionFilter: | |
Enabled: true | |
EnforcedStyle: action | |
# Checks the correct usage of date aware methods, such as `Date.today`, | |
# `Date.current`, etc. | |
Rails/Date: | |
Enabled: false | |
# Prefer delegate method for delegations. | |
Rails/Delegate: | |
Enabled: false | |
# Prefer `find_by` over `where.first`. | |
Rails/FindBy: | |
Enabled: true | |
# Prefer `all.find_each` over `all.find`. | |
Rails/FindEach: | |
Enabled: true | |
# Prefer has_many :through to has_and_belongs_to_many. | |
Rails/HasAndBelongsToMany: | |
Enabled: true | |
# Checks for calls to puts, print, etc. | |
Rails/Output: | |
Enabled: true | |
# Checks for incorrect grammar when using methods like `3.day.ago`. | |
Rails/PluralizationGrammar: | |
Enabled: true | |
# Checks for `read_attribute(:attr)` and `write_attribute(:attr, val)`. | |
Rails/ReadWriteAttribute: | |
Enabled: false | |
# Checks the arguments of ActiveRecord scopes. | |
Rails/ScopeArgs: | |
Enabled: true | |
# Checks the correct usage of time zone aware methods. | |
# http://danilenko.org/2012/7/6/rails_timezones | |
Rails/TimeZone: | |
Enabled: false | |
# Use validates :attribute, hash of validations. | |
Rails/Validation: | |
Enabled: false | |
Rails/UniqBeforePluck: | |
Enabled: false |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment