kotovalexarian-likes-github
/
paper-trail-gem--paper_trail
mirror of https://github.com/paper-trail-gem/paper_trail.git
1
0
Fork 0
Code Releases Activity
paper-trail-gem--paper_trail/.rubocop.yml

854 lines
21 KiB
YAML
Raw Normal View History

Install rubocop
2015-11-02 02:33:16 +00:00
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