.rubocop.yml

# This is the default configuration file. Enabling and disabling is configured
# in separate files. This file adds all other parameters apart from Enabled.

inherit_from:
#  - enabled.yml
#  - disabled.yml

require:
- rubocop-rails

# Common configuration.
AllCops:
  TargetRubyVersion: 2.4

  TargetRailsVersion: 5.2

  # Include common Ruby source files.
  Include:
    - '**/*.gemspec'
    - '**/*.gemfile'
    - '**/*.podspec'
    - '**/*.jbuilder'
    - '**/*.rake'
    - '**/*.opal'
    - '**/config.ru'
    - '**/Gemfile'
    - '**/Rakefile'
    - '**/Capfile'
    - '**/Guardfile'
    - '**/Podfile'
    - '**/Thorfile'
    - '**/Vagrantfile'
    - '**/Berksfile'
    - '**/Cheffile'
    - '**/Vagabondfile'
    - rubocop-rspec
  Exclude:
    - 'vendor/**/*'
    - db/schema.rb
  # Cop names are not displayed in offense messages by default. Change behavior
  # by overriding DisplayCopNames, or by giving the -D/--display-cop-names
  # option.
  DisplayCopNames: false
  # Style guide URLs are not displayed in offense messages by default. Change
  # behavior by overriding DisplayStyleGuide, or by giving the
  # -S/--display-style-guide option.
  DisplayStyleGuide: false
  # Additional cops that do not reference a style guide rule may be enabled by
  # default. Change behavior by overriding StyleGuideCopsOnly, or by giving
  # the --only-guide-cops option.
  StyleGuideCopsOnly: false

Documentation:
  Enabled: false

# Indent private/protected/public as deep as method definitions
Layout/AccessModifierIndentation:
  EnforcedStyle: indent
  SupportedStyles:
    - outdent
    - indent

# Align the elements of a hash literal if they span more than one line.
Layout/HashAlignment:
  # 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

# disabled since it can give conflicting advice, specially in inheritance
# or composition cases,
Style/Alias:
  Enabled: false

Layout/ParameterAlignment:
  # 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:
  EnforcedStyle: line_count_based
  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

# Indentation of `when`.
Layout/CaseIndentation:
  SupportedStyles:
    - case
    - end
  IndentOneStep: false

Style/ClassAndModuleChildren:
  Enabled: false
  # 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: compact
  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

Style/AsciiComments:
  Enabled: false

# 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: ''

# Multi-line method chaining should be done with leading dots.
Layout/DotPosition:
  EnforcedStyle: leading
  SupportedStyles:
    - leading
    - trailing

Style/DoubleNegation:
  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.
Layout/EmptyLineBetweenDefs:
  # If true, this parameter means that single line method definitions don't
  # need an empty line between them.
  AllowAdjacentOneLineDefs: false

Layout/EmptyLineAfterMagicComment:
  Enabled: false

Layout/EmptyLinesAroundBlockBody:
  EnforcedStyle: no_empty_lines
  SupportedStyles:
    - empty_lines
    - no_empty_lines

Layout/EmptyLinesAroundClassBody:
  EnforcedStyle: no_empty_lines
  SupportedStyles:
    - empty_lines
    - no_empty_lines

Layout/EmptyLinesAroundModuleBody:
  EnforcedStyle: no_empty_lines
  SupportedStyles:
    - empty_lines
    - no_empty_lines

Naming/FileName:
  # File names listed in AllCops:Include are excluded by default. Add extra
  # excludes here.
  Exclude: []

Layout/FirstParameterIndentation:
  EnforcedStyle: consistent
  SupportedStyles:
    # The first parameter should always be indented one step more than the
    # preceding line.
    - consistent
    - align_parentheses

Style/EmptyMethod:
  EnforcedStyle: expanded
  SupportedStyles:
    - compact
    - expanded

# 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

# Enforce using either `%<token>s` or `%{token}`
Style/FormatStringToken:
  EnforcedStyle: annotated
  SupportedStyles:
    # Prefer tokens which contain a sprintf like type annotation like
    # `%<name>s`, `%<age>d`, `%<score>f`
    - annotated
    # Prefer simple looking "template" style tokens like `%{name}`, `%{age}`
    - template

Style/FrozenStringLiteralComment:
  EnforcedStyle: always
  SupportedStyles:
    - always_true
    # `always` will always add the frozen string literal comment to a file
    # regardless of the Ruby version or if `freeze` or `<<` are called on a
    # string literal. If you run code against multiple versions of Ruby, it is
    # possible that this will create errors in Ruby 2.3.0+.
    - always
    # `never` will enforce that the frozen string literal comment does not
    # exist in a file.
    - never

# Built-in global variables are allowed by default.
Style/GlobalVars:
  AllowedVariables: []

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

Layout/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

Layout/IndentationWidth:
  # Number of spaces for each indentation level.
  Width: 2

# Checks the indentation of the first key in a hash literal.
Layout/FirstHashElementIndentation:
  # 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:
  EnforcedStyle: literal

Style/LambdaCall:
  EnforcedStyle: call
  SupportedStyles:
    - call
    - braces

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

Naming/MethodName:
  EnforcedStyle: snake_case
  SupportedStyles:
    - snake_case
    - camelCase

Layout/MultilineOperationIndentation:
  EnforcedStyle: aligned
  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

Naming/PredicateName:
  # Predicate name prefices.
  NamePrefix:
    - is_
    - has_
    - have_
  # Predicate name prefices that should be removed.
  ForbiddenPrefixes:
    - is_
    - has_
    - have_

Style/RaiseArgs:
  Severity: warning
  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/SafeNavigation:
  Enabled: false
  # Safe navigation may cause a statement to start returning `nil` in addition
  # to whatever it used to return.
  ConvertCodeThatCanStartToReturnNil: false

Style/Semicolon:
  # Allow ; to separate several expressions on the same line.
  AllowAsExpressionSeparator: false

Style/SignalException:
  EnforcedStyle: only_raise
  SupportedStyles:
    - only_raise
    - only_fail
    - semantic

Style/SingleLineBlockParams:
  Methods:
    - reduce:
        - a
        - e
    - inject:
        - a
        - e

Style/SingleLineMethods:
  AllowIfMethodIsEmpty: true

Style/StringLiterals:
  EnforcedStyle: single_quotes
  SupportedStyles:
    - single_quotes
    - double_quotes

Style/StringLiteralsInInterpolation:
  EnforcedStyle: single_quotes
  SupportedStyles:
    - single_quotes
    - double_quotes

Layout/SpaceAroundBlockParameters:
  EnforcedStyleInsidePipes: no_space
  SupportedStylesInsidePipes:
    - space
    - no_space

Layout/SpaceAroundEqualsInParameterDefault:
  EnforcedStyle: space
  SupportedStyles:
    - space
    - no_space

Layout/SpaceAroundOperators:
  # When true, allows most uses of extra spacing if the intent is to align
  # with an operator on the previous or next line, not counting empty lines
  # or comment lines.
  AllowForAlignment: true

Layout/SpaceBeforeBlockBraces:
  EnforcedStyle: space
  SupportedStyles:
    - space
    - no_space

Layout/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

Layout/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

Layout/TrailingEmptyLines:
  EnforcedStyle: final_newline
  SupportedStyles:
    - final_newline
    - final_blank_line

Style/TrailingCommaInArrayLiteral:
  # 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
  SupportedStylesForMultiline:
    - comma
    - consistent_comma
    - no_comma

Style/TrailingCommaInHashLiteral:
  # 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
  SupportedStylesForMultiline:
    - comma
    - consistent_comma
    - no_comma

Style/TrailingCommaInArguments:
  # 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
  SupportedStylesForMultiline:
    - 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
  AllowedMethods:
    - 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

Naming/VariableName:
  EnforcedStyle: snake_case
  SupportedStyles:
    - snake_case
    - camelCase

Style/WordArray:
  MinSize: 0
  # The regular expression WordRegex decides what is considered a word.
  WordRegex: !ruby/regexp '/\A[\p{Word}]+\z/'

##################### Metrics ##################################

Metrics/AbcSize:
  Severity: warning
  # The ABC size is a calculated magnitude, so this number can be a Fixnum or
  # a Float.
  Max: 25
  Exclude:
    - 'db/**/*.rb'

Metrics/BlockNesting:
  Max: 3

Metrics/BlockLength:
  Exclude:
    - 'Rakefile'
    - '**/*.rake'
    - 'spec/factories/*.rb'
    - 'spec/**/*_spec.rb'
    - 'app/admin/**/*'
    - 'app/indices/**/*.rb'

# Second-wave metric. Disabled now to prevent noise.
Metrics/ClassLength:
  Enabled: false
  CountComments: false  # count full line comments?
  Max: 100

# Second-wave metric. Disabled now to prevent noise.
Metrics/ModuleLength:
  Enabled: false
  CountComments: false  # count full line comments?
  Max: 100

# Avoid complex methods.
Metrics/CyclomaticComplexity:
  Max: 6

# Second-wave metric. Disabled now to prevent noise.
Layout/LineLength:
  Enabled: false
  Max: 120
  # 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

# Second-wave metric. Disabled now to prevent noise.
Metrics/MethodLength:
  Enabled: false
  Severity: warning
  CountComments: false  # count full line comments?
  Max: 20

Metrics/ParameterLists:
  Max: 5
  CountKeywordArgs: true

Metrics/PerceivedComplexity:
  Max: 7

##################### Lint ##################################

# Allow safe assignment in conditions.
Lint/AssignmentInCondition:
  AllowSafeAssignment: true

# Align ends correctly.
Layout/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.
  EnforcedStyleAlignWith: keyword
  SupportedStylesAlignWith:
    - keyword
    - variable
    - start_of_line
  AutoCorrect: false

Layout/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.
  EnforcedStyleAlignWith: start_of_line
  SupportedStylesAlignWith:
    - start_of_line
    - def
  AutoCorrect: false

##################### Rails ##################################
Rails:
  Enabled: false

Rails/ActionFilter:
  EnforcedStyle: action
  SupportedStyles:
    - action
    - filter
  Include:
    - app/controllers/**/*.rb

Rails/Blank:
  Enabled: true
  # Convert checks for `nil` or `empty?` to `blank?`
  NilOrEmpty: true
  # Convert usages of not `present?` to `blank?`
  NotPresent: true
  # Convert usages of `unless` `present?` to `if` `blank?`
  UnlessPresent: false

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: flexible
  SupportedStyles:
    - strict
    - flexible

Rails/FindBy:
  Enabled: false
  Include:
    - app/models/**/*.rb
    - app/controllers/**/*.rb
    - app/observers/**/*.rb
    - app/services/**/*.rb
    - app/mailers/**/*.rb
    - app/helpers/**/*.rb
    - app/policies/**/*.rb
    - lib/**/*.rb

Rails/FindEach:
  Include:
    - app/models/**/*.rb
    - app/controllers/**/*.rb
    - app/observers/**/*.rb
    - app/services/**/*.rb
    - app/mailers/**/*.rb
    - app/helpers/**/*.rb
    - app/policies/**/*.rb
    - lib/**/*.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: flexible
  SupportedStyles:
    - strict
    - flexible

Rails/Validation:
  Include:
    - app/models/**/*.rb