Install rubocop
This commit is contained in:
parent
8402e1be2b
commit
7d8775feae
|
@ -0,0 +1,853 @@
|
|||
AllCops:
|
||||
Include:
|
||||
- 'lib/**/*.rb'
|
||||
- 'paper_trail.gemspec'
|
||||
- 'Gemfile'
|
||||
- 'Rakefile'
|
||||
Exclude:
|
||||
- 'spec/**/*'
|
||||
- 'test/**/*'
|
||||
RunRailsCops: false
|
||||
DisplayCopNames: true
|
||||
DisplayStyleGuide: true
|
||||
StyleGuideCopsOnly: false
|
||||
|
||||
# Indent private/protected/public as deep as method definitions
|
||||
Style/AccessModifierIndentation:
|
||||
EnforcedStyle: indent
|
||||
SupportedStyles:
|
||||
- outdent
|
||||
- indent
|
||||
|
||||
# Align the elements of a hash literal if they span more than one line.
|
||||
Style/AlignHash:
|
||||
# Alignment of entries using hash rocket as separator. Valid values are:
|
||||
#
|
||||
# key - left alignment of keys
|
||||
# 'a' => 2
|
||||
# 'bb' => 3
|
||||
# separator - alignment of hash rockets, keys are right aligned
|
||||
# 'a' => 2
|
||||
# 'bb' => 3
|
||||
# table - left alignment of keys, hash rockets, and values
|
||||
# 'a' => 2
|
||||
# 'bb' => 3
|
||||
EnforcedHashRocketStyle: key
|
||||
# Alignment of entries using colon as separator. Valid values are:
|
||||
#
|
||||
# key - left alignment of keys
|
||||
# a: 0
|
||||
# bb: 1
|
||||
# separator - alignment of colons, keys are right aligned
|
||||
# a: 0
|
||||
# bb: 1
|
||||
# table - left alignment of keys and values
|
||||
# a: 0
|
||||
# bb: 1
|
||||
EnforcedColonStyle: key
|
||||
# Select whether hashes that are the last argument in a method call should be
|
||||
# inspected? Valid values are:
|
||||
#
|
||||
# always_inspect - Inspect both implicit and explicit hashes.
|
||||
# Registers an offense for:
|
||||
# function(a: 1,
|
||||
# b: 2)
|
||||
# Registers an offense for:
|
||||
# function({a: 1,
|
||||
# b: 2})
|
||||
# always_ignore - Ignore both implicit and explicit hashes.
|
||||
# Accepts:
|
||||
# function(a: 1,
|
||||
# b: 2)
|
||||
# Accepts:
|
||||
# function({a: 1,
|
||||
# b: 2})
|
||||
# ignore_implicit - Ignore only implicit hashes.
|
||||
# Accepts:
|
||||
# function(a: 1,
|
||||
# b: 2)
|
||||
# Registers an offense for:
|
||||
# function({a: 1,
|
||||
# b: 2})
|
||||
# ignore_explicit - Ignore only explicit hashes.
|
||||
# Accepts:
|
||||
# function({a: 1,
|
||||
# b: 2})
|
||||
# Registers an offense for:
|
||||
# function(a: 1,
|
||||
# b: 2)
|
||||
EnforcedLastArgumentHashStyle: always_inspect
|
||||
SupportedLastArgumentHashStyles:
|
||||
- always_inspect
|
||||
- always_ignore
|
||||
- ignore_implicit
|
||||
- ignore_explicit
|
||||
|
||||
Style/AlignParameters:
|
||||
# Alignment of parameters in multi-line method calls.
|
||||
#
|
||||
# The `with_first_parameter` style aligns the following lines along the same
|
||||
# column as the first parameter.
|
||||
#
|
||||
# method_call(a,
|
||||
# b)
|
||||
#
|
||||
# The `with_fixed_indentation` style aligns the following lines with one
|
||||
# level of indentation relative to the start of the line with the method call.
|
||||
#
|
||||
# method_call(a,
|
||||
# b)
|
||||
EnforcedStyle: with_fixed_indentation
|
||||
SupportedStyles:
|
||||
- with_first_parameter
|
||||
- with_fixed_indentation
|
||||
|
||||
Style/AndOr:
|
||||
# Whether `and` and `or` are banned only in conditionals (conditionals)
|
||||
# or completely (always).
|
||||
EnforcedStyle: always
|
||||
SupportedStyles:
|
||||
- always
|
||||
- conditionals
|
||||
|
||||
|
||||
# Checks if usage of %() or %Q() matches configuration.
|
||||
Style/BarePercentLiterals:
|
||||
EnforcedStyle: bare_percent
|
||||
SupportedStyles:
|
||||
- percent_q
|
||||
- bare_percent
|
||||
|
||||
Style/BlockDelimiters:
|
||||
Exclude:
|
||||
- 'spec/factories/**/*'
|
||||
EnforcedStyle: semantic
|
||||
SupportedStyles:
|
||||
# The `line_count_based` style enforces braces around single line blocks and
|
||||
# do..end around multi-line blocks.
|
||||
- line_count_based
|
||||
# The `semantic` style enforces braces around functional blocks, where the
|
||||
# primary purpose of the block is to return a value and do..end for
|
||||
# procedural blocks, where the primary purpose of the block is its
|
||||
# side-effects.
|
||||
#
|
||||
# This looks at the usage of a block's method to determine its type (e.g. is
|
||||
# the result of a `map` assigned to a variable or passed to another
|
||||
# method) but exceptions are permitted in the `ProceduralMethods`,
|
||||
# `FunctionalMethods` and `IgnoredMethods` sections below.
|
||||
- semantic
|
||||
ProceduralMethods:
|
||||
# Methods that are known to be procedural in nature but look functional from
|
||||
# their usage, e.g.
|
||||
#
|
||||
# time = Benchmark.realtime do
|
||||
# foo.bar
|
||||
# end
|
||||
#
|
||||
# Here, the return value of the block is discarded but the return value of
|
||||
# `Benchmark.realtime` is used.
|
||||
- benchmark
|
||||
- bm
|
||||
- bmbm
|
||||
- create
|
||||
- each_with_object
|
||||
- measure
|
||||
- new
|
||||
- realtime
|
||||
- tap
|
||||
- with_object
|
||||
FunctionalMethods:
|
||||
# Methods that are known to be functional in nature but look procedural from
|
||||
# their usage, e.g.
|
||||
#
|
||||
# let(:foo) { Foo.new }
|
||||
#
|
||||
# Here, the return value of `Foo.new` is used to define a `foo` helper but
|
||||
# doesn't appear to be used from the return value of `let`.
|
||||
- let
|
||||
- let!
|
||||
- subject
|
||||
- watch
|
||||
IgnoredMethods:
|
||||
# Methods that can be either procedural or functional and cannot be
|
||||
# categorised from their usage alone, e.g.
|
||||
#
|
||||
# foo = lambda do |x|
|
||||
# puts "Hello, #{x}"
|
||||
# end
|
||||
#
|
||||
# foo = lambda do |x|
|
||||
# x * 100
|
||||
# end
|
||||
#
|
||||
# Here, it is impossible to tell from the return value of `lambda` whether
|
||||
# the inner block's return value is significant.
|
||||
- lambda
|
||||
- proc
|
||||
- it
|
||||
- template_param
|
||||
|
||||
Style/BracesAroundHashParameters:
|
||||
EnforcedStyle: no_braces
|
||||
SupportedStyles:
|
||||
# The `braces` style enforces braces around all method parameters that are
|
||||
# hashes.
|
||||
- braces
|
||||
# The `no_braces` style checks that the last parameter doesn't have braces
|
||||
# around it.
|
||||
- no_braces
|
||||
# The `context_dependent` style checks that the last parameter doesn't have
|
||||
# braces around it, but requires braces if the second to last parameter is
|
||||
# also a hash literal.
|
||||
- context_dependent
|
||||
|
||||
# Indentation of `when`.
|
||||
Style/CaseIndentation:
|
||||
IndentWhenRelativeTo: case
|
||||
SupportedStyles:
|
||||
- case
|
||||
- end
|
||||
IndentOneStep: false
|
||||
|
||||
Style/ClassAndModuleChildren:
|
||||
# Checks the style of children definitions at classes and modules.
|
||||
#
|
||||
# Basically there are two different styles:
|
||||
#
|
||||
# `nested` - have each child on a separate line
|
||||
# class Foo
|
||||
# class Bar
|
||||
# end
|
||||
# end
|
||||
#
|
||||
# `compact` - combine definitions as much as possible
|
||||
# class Foo::Bar
|
||||
# end
|
||||
#
|
||||
# The compact style is only forced, for classes / modules with one child.
|
||||
EnforcedStyle: nested
|
||||
SupportedStyles:
|
||||
- nested
|
||||
- compact
|
||||
|
||||
Style/ClassCheck:
|
||||
EnforcedStyle: is_a?
|
||||
SupportedStyles:
|
||||
- is_a?
|
||||
- kind_of?
|
||||
|
||||
# Align with the style guide.
|
||||
Style/CollectionMethods:
|
||||
# Mapping from undesired method to desired_method
|
||||
# e.g. to use `detect` over `find`:
|
||||
#
|
||||
# CollectionMethods:
|
||||
# PreferredMethods:
|
||||
# find: detect
|
||||
PreferredMethods:
|
||||
collect: 'map'
|
||||
collect!: 'map!'
|
||||
inject: 'reduce'
|
||||
detect: 'find'
|
||||
find_all: 'select'
|
||||
|
||||
# Use ` or %x around command literals.
|
||||
Style/CommandLiteral:
|
||||
EnforcedStyle: backticks
|
||||
# backticks: Always use backticks.
|
||||
# percent_x: Always use %x.
|
||||
# mixed: Use backticks on single-line commands, and %x on multi-line commands.
|
||||
SupportedStyles:
|
||||
- backticks
|
||||
- percent_x
|
||||
- mixed
|
||||
# If false, the cop will always recommend using %x if one or more backticks
|
||||
# are found in the command string.
|
||||
AllowInnerBackticks: false
|
||||
|
||||
# Checks formatting of special comments
|
||||
Style/CommentAnnotation:
|
||||
Keywords:
|
||||
- TODO
|
||||
- FIXME
|
||||
- OPTIMIZE
|
||||
- HACK
|
||||
- REVIEW
|
||||
|
||||
# Checks that you have put a copyright in a comment before any code.
|
||||
#
|
||||
# You can override the default Notice in your .rubocop.yml file.
|
||||
#
|
||||
# In order to use autocorrect, you must supply a value for the
|
||||
# AutocorrectNotice key that matches the regexp Notice. A blank
|
||||
# AutocorrectNotice will cause an error during autocorrect.
|
||||
#
|
||||
# Autocorrect will add a copyright notice in a comment at the top
|
||||
# of the file immediately after any shebang or encoding comments.
|
||||
#
|
||||
# Example rubocop.yml:
|
||||
#
|
||||
# Style/Copyright:
|
||||
# Enabled: true
|
||||
# Notice: 'Copyright (\(c\) )?2015 Yahoo! Inc'
|
||||
# AutocorrectNotice: '# Copyright (c) 2015 Yahoo! Inc.'
|
||||
#
|
||||
Style/Copyright:
|
||||
Notice: '^Copyright (\(c\) )?2[0-9]{3} .+'
|
||||
AutocorrectNotice: ''
|
||||
|
||||
Style/Documentation:
|
||||
Enabled: false
|
||||
|
||||
# Multi-line method chaining should be done with leading dots.
|
||||
Style/DotPosition:
|
||||
EnforcedStyle: trailing
|
||||
SupportedStyles:
|
||||
- leading
|
||||
- trailing
|
||||
|
||||
Style/DoubleNegation:
|
||||
Description: 'Checks for uses of double negation (!!).'
|
||||
StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-bang-bang'
|
||||
Enabled: false
|
||||
|
||||
# Warn on empty else statements
|
||||
# empty - warn only on empty else
|
||||
# nil - warn on else with nil in it
|
||||
# both - warn on empty else and else with nil in it
|
||||
Style/EmptyElse:
|
||||
EnforcedStyle: both
|
||||
SupportedStyles:
|
||||
- empty
|
||||
- nil
|
||||
- both
|
||||
|
||||
# Use empty lines between defs.
|
||||
Style/EmptyLineBetweenDefs:
|
||||
# If true, this parameter means that single line method definitions don't
|
||||
# need an empty line between them.
|
||||
AllowAdjacentOneLineDefs: false
|
||||
|
||||
Style/EmptyLinesAroundBlockBody:
|
||||
EnforcedStyle: no_empty_lines
|
||||
SupportedStyles:
|
||||
- empty_lines
|
||||
- no_empty_lines
|
||||
|
||||
Style/EmptyLinesAroundClassBody:
|
||||
EnforcedStyle: no_empty_lines
|
||||
SupportedStyles:
|
||||
- empty_lines
|
||||
- no_empty_lines
|
||||
|
||||
Style/EmptyLinesAroundModuleBody:
|
||||
EnforcedStyle: no_empty_lines
|
||||
SupportedStyles:
|
||||
- empty_lines
|
||||
- no_empty_lines
|
||||
|
||||
# Checks whether the source file has a utf-8 encoding comment or not
|
||||
# AutoCorrectEncodingComment must match the regex
|
||||
# /#.*coding\s?[:=]\s?(?:UTF|utf)-8/
|
||||
Style/Encoding:
|
||||
EnforcedStyle: always
|
||||
SupportedStyles:
|
||||
- when_needed
|
||||
- always
|
||||
AutoCorrectEncodingComment: '# encoding: utf-8'
|
||||
|
||||
Style/FileName:
|
||||
# File names listed in AllCops:Include are excluded by default. Add extra
|
||||
# excludes here.
|
||||
Exclude: []
|
||||
|
||||
Style/FirstParameterIndentation:
|
||||
EnforcedStyle: special_for_inner_method_call_in_parentheses
|
||||
SupportedStyles:
|
||||
# The first parameter should always be indented one step more than the
|
||||
# preceding line.
|
||||
- consistent
|
||||
# The first parameter should normally be indented one step more than the
|
||||
# preceding line, but if it's a parameter for a method call that is itself
|
||||
# a parameter in a method call, then the inner parameter should be indented
|
||||
# relative to the inner method.
|
||||
- special_for_inner_method_call
|
||||
# Same as special_for_inner_method_call except that the special rule only
|
||||
# applies if the outer method call encloses its arguments in parentheses.
|
||||
- special_for_inner_method_call_in_parentheses
|
||||
|
||||
# Checks use of for or each in multiline loops.
|
||||
Style/For:
|
||||
EnforcedStyle: each
|
||||
SupportedStyles:
|
||||
- for
|
||||
- each
|
||||
|
||||
# Enforce the method used for string formatting.
|
||||
Style/FormatString:
|
||||
EnforcedStyle: format
|
||||
SupportedStyles:
|
||||
- format
|
||||
- sprintf
|
||||
- percent
|
||||
|
||||
# Built-in global variables are allowed by default.
|
||||
Style/GlobalVars:
|
||||
AllowedVariables: []
|
||||
|
||||
# `MinBodyLength` defines the number of lines of the a body of an if / unless
|
||||
# needs to have to trigger this cop
|
||||
Style/GuardClause:
|
||||
MinBodyLength: 2
|
||||
|
||||
Style/HashSyntax:
|
||||
EnforcedStyle: ruby19
|
||||
SupportedStyles:
|
||||
- ruby19
|
||||
- ruby19_no_mixed_keys
|
||||
- hash_rockets
|
||||
# Force hashes that have a symbol value to use hash rockets
|
||||
UseHashRocketsWithSymbolValues: false
|
||||
|
||||
Style/IfUnlessModifier:
|
||||
MaxLineLength: 60
|
||||
|
||||
Style/IndentationConsistency:
|
||||
# The difference between `rails` and `normal` is that the `rails` style
|
||||
# prescribes that in classes and modules the `protected` and `private`
|
||||
# modifier keywords shall be indented the same as public methods and that
|
||||
# protected and private members shall be indented one step more than the
|
||||
# modifiers. Other than that, both styles mean that entities on the same
|
||||
# logical depth shall have the same indentation.
|
||||
EnforcedStyle: normal
|
||||
SupportedStyles:
|
||||
- normal
|
||||
- rails
|
||||
|
||||
Style/IndentationWidth:
|
||||
# Number of spaces for each indentation level.
|
||||
Width: 2
|
||||
|
||||
# Checks the indentation of the first key in a hash literal.
|
||||
Style/IndentHash:
|
||||
# The value `special_inside_parentheses` means that hash literals with braces
|
||||
# that have their opening brace on the same line as a surrounding opening
|
||||
# round parenthesis, shall have their first key indented relative to the
|
||||
# first position inside the parenthesis.
|
||||
# The value `consistent` means that the indentation of the first key shall
|
||||
# always be relative to the first position of the line where the opening
|
||||
# brace is.
|
||||
EnforcedStyle: special_inside_parentheses
|
||||
SupportedStyles:
|
||||
- special_inside_parentheses
|
||||
- consistent
|
||||
|
||||
Style/Lambda:
|
||||
Enabled: false
|
||||
|
||||
Style/LambdaCall:
|
||||
EnforcedStyle: call
|
||||
SupportedStyles:
|
||||
- call
|
||||
- braces
|
||||
|
||||
Style/LineEndConcatenation:
|
||||
Enabled: false
|
||||
|
||||
Style/Next:
|
||||
# With `always` all conditions at the end of an iteration needs to be
|
||||
# replaced by next - with `skip_modifier_ifs` the modifier if like this one
|
||||
# are ignored: [1, 2].each { |a| return 'yes' if a == 1 }
|
||||
EnforcedStyle: skip_modifier_ifs
|
||||
# `MinBodyLength` defines the number of lines of the a body of an if / unless
|
||||
# needs to have to trigger this cop
|
||||
MinBodyLength: 3
|
||||
SupportedStyles:
|
||||
- skip_modifier_ifs
|
||||
- always
|
||||
|
||||
Style/NonNilCheck:
|
||||
# With `IncludeSemanticChanges` set to `true`, this cop reports offenses for
|
||||
# `!x.nil?` and autocorrects that and `x != nil` to solely `x`, which is
|
||||
# **usually** OK, but might change behavior.
|
||||
#
|
||||
# With `IncludeSemanticChanges` set to `false`, this cop does not report
|
||||
# offenses for `!x.nil?` and does no changes that might change behavior.
|
||||
IncludeSemanticChanges: false
|
||||
|
||||
Style/MethodDefParentheses:
|
||||
EnforcedStyle: require_parentheses
|
||||
SupportedStyles:
|
||||
- require_parentheses
|
||||
- require_no_parentheses
|
||||
|
||||
Style/MethodName:
|
||||
EnforcedStyle: snake_case
|
||||
SupportedStyles:
|
||||
- snake_case
|
||||
- camelCase
|
||||
|
||||
Style/MultilineOperationIndentation:
|
||||
EnforcedStyle: indented
|
||||
SupportedStyles:
|
||||
- aligned
|
||||
- indented
|
||||
|
||||
Style/NumericLiterals:
|
||||
MinDigits: 5
|
||||
|
||||
# Allow safe assignment in conditions.
|
||||
Style/ParenthesesAroundCondition:
|
||||
AllowSafeAssignment: true
|
||||
|
||||
Style/PercentLiteralDelimiters:
|
||||
PreferredDelimiters:
|
||||
'%': ()
|
||||
'%i': '[]'
|
||||
'%q': ()
|
||||
'%Q': ()
|
||||
'%r': '{}'
|
||||
'%s': ()
|
||||
'%w': '[]'
|
||||
'%W': '[]'
|
||||
'%x': ()
|
||||
|
||||
Style/PercentQLiterals:
|
||||
EnforcedStyle: lower_case_q
|
||||
SupportedStyles:
|
||||
- lower_case_q # Use %q when possible, %Q when necessary
|
||||
- upper_case_q # Always use %Q
|
||||
|
||||
Style/PredicateName:
|
||||
# Predicate name prefices.
|
||||
NamePrefix:
|
||||
- is_
|
||||
- has_
|
||||
- have_
|
||||
# Predicate name prefices that should be removed.
|
||||
NamePrefixBlacklist:
|
||||
- is_
|
||||
- has_
|
||||
- have_
|
||||
|
||||
Style/RaiseArgs:
|
||||
EnforcedStyle: exploded
|
||||
SupportedStyles:
|
||||
- compact # raise Exception.new(msg)
|
||||
- exploded # raise Exception, msg
|
||||
|
||||
Style/RedundantReturn:
|
||||
# When true allows code like `return x, y`.
|
||||
AllowMultipleReturnValues: false
|
||||
|
||||
# Use / or %r around regular expressions.
|
||||
Style/RegexpLiteral:
|
||||
EnforcedStyle: slashes
|
||||
# slashes: Always use slashes.
|
||||
# percent_r: Always use %r.
|
||||
# mixed: Use slashes on single-line regexes, and %r on multi-line regexes.
|
||||
SupportedStyles:
|
||||
- slashes
|
||||
- percent_r
|
||||
- mixed
|
||||
# If false, the cop will always recommend using %r if one or more slashes
|
||||
# are found in the regexp string.
|
||||
AllowInnerSlashes: false
|
||||
|
||||
Style/Semicolon:
|
||||
# Allow ; to separate several expressions on the same line.
|
||||
AllowAsExpressionSeparator: false
|
||||
|
||||
Style/SignalException:
|
||||
EnforcedStyle: semantic
|
||||
SupportedStyles:
|
||||
- only_raise
|
||||
- only_fail
|
||||
- semantic
|
||||
|
||||
Style/SingleLineBlockParams:
|
||||
Methods:
|
||||
- reduce:
|
||||
- a
|
||||
- e
|
||||
- inject:
|
||||
- a
|
||||
- e
|
||||
|
||||
Style/SingleLineMethods:
|
||||
AllowIfMethodIsEmpty: true
|
||||
|
||||
Style/StringLiterals:
|
||||
Enabled: false
|
||||
EnforcedStyle: double_quotes
|
||||
SupportedStyles:
|
||||
- single_quotes
|
||||
- double_quotes
|
||||
|
||||
Style/StringLiteralsInInterpolation:
|
||||
EnforcedStyle: single_quotes
|
||||
SupportedStyles:
|
||||
- single_quotes
|
||||
- double_quotes
|
||||
|
||||
Style/SpaceAroundBlockParameters:
|
||||
EnforcedStyleInsidePipes: no_space
|
||||
SupportedStyles:
|
||||
- space
|
||||
- no_space
|
||||
|
||||
Style/SpaceAroundEqualsInParameterDefault:
|
||||
EnforcedStyle: space
|
||||
SupportedStyles:
|
||||
- space
|
||||
- no_space
|
||||
|
||||
Style/SpaceAroundOperators:
|
||||
MultiSpaceAllowedForOperators:
|
||||
- '='
|
||||
- '=>'
|
||||
|
||||
Style/SpaceBeforeBlockBraces:
|
||||
EnforcedStyle: space
|
||||
SupportedStyles:
|
||||
- space
|
||||
- no_space
|
||||
|
||||
Style/SpaceInsideBlockBraces:
|
||||
EnforcedStyle: space
|
||||
SupportedStyles:
|
||||
- space
|
||||
- no_space
|
||||
# Valid values are: space, no_space
|
||||
EnforcedStyleForEmptyBraces: no_space
|
||||
# Space between { and |. Overrides EnforcedStyle if there is a conflict.
|
||||
SpaceBeforeBlockParameters: true
|
||||
|
||||
Style/SpaceInsideHashLiteralBraces:
|
||||
EnforcedStyle: space
|
||||
EnforcedStyleForEmptyBraces: no_space
|
||||
SupportedStyles:
|
||||
- space
|
||||
- no_space
|
||||
|
||||
Style/SymbolProc:
|
||||
# A list of method names to be ignored by the check.
|
||||
# The names should be fairly unique, otherwise you'll end up ignoring lots of code.
|
||||
IgnoredMethods:
|
||||
- respond_to
|
||||
|
||||
Style/TrailingBlankLines:
|
||||
EnforcedStyle: final_newline
|
||||
SupportedStyles:
|
||||
- final_newline
|
||||
- final_blank_line
|
||||
|
||||
Style/TrailingComma:
|
||||
# If EnforcedStyleForMultiline is comma, the cop requires a comma after the
|
||||
# last item of a list, but only for lists where each item is on its own line.
|
||||
# If EnforcedStyleForMultiline is consistent_comma, the cop requires a comma
|
||||
# after the last item of a list, for all lists.
|
||||
EnforcedStyleForMultiline: no_comma
|
||||
SupportedStyles:
|
||||
- comma
|
||||
- consistent_comma
|
||||
- no_comma
|
||||
|
||||
# TrivialAccessors requires exact name matches and doesn't allow
|
||||
# predicated methods by default.
|
||||
Style/TrivialAccessors:
|
||||
# When set to false the cop will suggest the use of accessor methods
|
||||
# in situations like:
|
||||
#
|
||||
# def name
|
||||
# @other_name
|
||||
# end
|
||||
#
|
||||
# This way you can uncover "hidden" attributes in your code.
|
||||
ExactNameMatch: true
|
||||
AllowPredicates: false
|
||||
# Allows trivial writers that don't end in an equal sign. e.g.
|
||||
#
|
||||
# def on_exception(action)
|
||||
# @on_exception=action
|
||||
# end
|
||||
# on_exception :restart
|
||||
#
|
||||
# Commonly used in DSLs
|
||||
AllowDSLWriters: false
|
||||
IgnoreClassMethods: false
|
||||
Whitelist:
|
||||
- to_ary
|
||||
- to_a
|
||||
- to_c
|
||||
- to_enum
|
||||
- to_h
|
||||
- to_hash
|
||||
- to_i
|
||||
- to_int
|
||||
- to_io
|
||||
- to_open
|
||||
- to_path
|
||||
- to_proc
|
||||
- to_r
|
||||
- to_regexp
|
||||
- to_str
|
||||
- to_s
|
||||
- to_sym
|
||||
|
||||
Style/VariableName:
|
||||
EnforcedStyle: snake_case
|
||||
SupportedStyles:
|
||||
- snake_case
|
||||
- camelCase
|
||||
|
||||
Style/WhileUntilModifier:
|
||||
MaxLineLength: 80
|
||||
|
||||
Style/WordArray:
|
||||
MinSize: 0
|
||||
# The regular expression WordRegex decides what is considered a word.
|
||||
WordRegex: !ruby/regexp '/\A[\p{Word}]+\z/'
|
||||
|
||||
##################### Metrics ##################################
|
||||
|
||||
Metrics/AbcSize:
|
||||
# The ABC size is a calculated magnitude, so this number can be a Fixnum or
|
||||
# a Float.
|
||||
Max: 15
|
||||
Exclude:
|
||||
- 'db/migrate/*'
|
||||
|
||||
Metrics/BlockNesting:
|
||||
Max: 3
|
||||
|
||||
Metrics/ClassLength:
|
||||
CountComments: false # count full line comments?
|
||||
Max: 100
|
||||
|
||||
Metrics/ModuleLength:
|
||||
CountComments: false # count full line comments?
|
||||
Max: 100
|
||||
|
||||
# Avoid complex methods.
|
||||
Metrics/CyclomaticComplexity:
|
||||
Max: 6
|
||||
|
||||
Metrics/LineLength:
|
||||
Max: 100
|
||||
# To make it possible to copy or click on URIs in the code, we allow lines
|
||||
# contaning a URI to be longer than Max.
|
||||
AllowURI: true
|
||||
URISchemes:
|
||||
- http
|
||||
- https
|
||||
|
||||
# Number of lines doesn't matter, only ABC complexity matters.
|
||||
Metrics/MethodLength:
|
||||
Enabled: false
|
||||
|
||||
Metrics/ParameterLists:
|
||||
Max: 5
|
||||
CountKeywordArgs: true
|
||||
|
||||
Metrics/PerceivedComplexity:
|
||||
Max: 7
|
||||
|
||||
##################### Lint ##################################
|
||||
|
||||
# Allow safe assignment in conditions.
|
||||
Lint/AssignmentInCondition:
|
||||
AllowSafeAssignment: true
|
||||
|
||||
# Align ends correctly.
|
||||
Lint/EndAlignment:
|
||||
# The value `keyword` means that `end` should be aligned with the matching
|
||||
# keyword (if, while, etc.).
|
||||
# The value `variable` means that in assignments, `end` should be aligned
|
||||
# with the start of the variable on the left hand side of `=`. In all other
|
||||
# situations, `end` should still be aligned with the keyword.
|
||||
AlignWith: keyword
|
||||
SupportedStyles:
|
||||
- keyword
|
||||
- variable
|
||||
AutoCorrect: false
|
||||
|
||||
Lint/DefEndAlignment:
|
||||
# The value `def` means that `end` should be aligned with the def keyword.
|
||||
# The value `start_of_line` means that `end` should be aligned with method
|
||||
# calls like `private`, `public`, etc, if present in front of the `def`
|
||||
# keyword on the same line.
|
||||
AlignWith: start_of_line
|
||||
SupportedStyles:
|
||||
- start_of_line
|
||||
- def
|
||||
AutoCorrect: false
|
||||
|
||||
Lint/HandleExceptions:
|
||||
Description: "Don't suppress exception."
|
||||
StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#dont-hide-exceptions'
|
||||
Enabled: false
|
||||
|
||||
##################### Rails ##################################
|
||||
|
||||
Rails/ActionFilter:
|
||||
EnforcedStyle: action
|
||||
SupportedStyles:
|
||||
- action
|
||||
- filter
|
||||
Include:
|
||||
- app/controllers/**/*.rb
|
||||
|
||||
Rails/Date:
|
||||
# The value `always` disallows usage of `Date.today`, `Date.current`,
|
||||
# `Date#to_time` etc.
|
||||
# The value `acceptable` allows usage of `Date.current`, `Date.yesterday`, etc
|
||||
# (but not `Date.today`) which are overriden by ActiveSupport to handle current
|
||||
# time zone.
|
||||
EnforcedStyle: always
|
||||
SupportedStyles:
|
||||
- always
|
||||
- acceptable
|
||||
|
||||
Rails/DefaultScope:
|
||||
Include:
|
||||
- app/models/**/*.rb
|
||||
|
||||
Rails/FindBy:
|
||||
Include:
|
||||
- app/models/**/*.rb
|
||||
|
||||
Rails/FindEach:
|
||||
Include:
|
||||
- app/models/**/*.rb
|
||||
|
||||
Rails/HasAndBelongsToMany:
|
||||
Include:
|
||||
- app/models/**/*.rb
|
||||
|
||||
Rails/Output:
|
||||
Include:
|
||||
- app/**/*.rb
|
||||
- config/**/*.rb
|
||||
- db/**/*.rb
|
||||
- lib/**/*.rb
|
||||
|
||||
Rails/ReadWriteAttribute:
|
||||
Include:
|
||||
- app/models/**/*.rb
|
||||
|
||||
Rails/ScopeArgs:
|
||||
Include:
|
||||
- app/models/**/*.rb
|
||||
|
||||
Rails/TimeZone:
|
||||
# The value `always` means that `Time` should be used with `zone`.
|
||||
# The value `acceptable` allows usage of `in_time_zone` instead of `zone`.
|
||||
EnforcedStyle: always
|
||||
SupportedStyles:
|
||||
- always
|
||||
- acceptable
|
||||
|
||||
Rails/Validation:
|
||||
Include:
|
||||
- app/models/**/*.rb
|
|
@ -35,6 +35,7 @@ Gem::Specification.new do |s|
|
|||
s.add_development_dependency 'generator_spec'
|
||||
s.add_development_dependency 'database_cleaner', '~> 1.2'
|
||||
s.add_development_dependency 'pry-nav'
|
||||
s.add_development_dependency 'rubocop'
|
||||
|
||||
# Allow time travel in testing. timecop is only supported after 1.9.2 but does a better cleanup at 'return'
|
||||
if RUBY_VERSION < "1.9.2"
|
||||
|
|
Loading…
Reference in New Issue