.rubocop.yml

# This is rubocop configuration file for Framgia's coding style. Enabling and disabling is configured
# in separate files. This file adds all other parameters apart from Enabled.

# Put the following files into the same directory as this file.
inherit_from:
  - .rubocop_enabled.yml
  - .rubocop_disabled.yml

# Common configuration.
AllCops:
  # Include gemspec and Rakefile
  Include:
    - '**/*.gemspec'
  Exclude:
    - 'vendor/**/*'
    - 'config/unicorn.rb'
    - 'bin/*'
    - 'db/**/*'
    - 'spec/**/*'
    - 'script/rails'
    - 'config/**/*'

# 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/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: ignore_implicit
  SupportedLastArgumentHashStyles:
    - always_inspect
    - always_ignore
    - ignore_implicit
    - ignore_explicit

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

Metrics/BlockNesting:
  Max: 3

Metrics/AbcSize:
  # The ABC size is a calculated magnitude, so this number can be a Fixnum or
  # a Float.
  Max: 20

Style/BracesAroundHashParameters:
  EnforcedStyle: no_braces
  SupportedStyles:
    - braces
    - no_braces

# Indentation of `when`.
Layout/CaseIndentation:
  EnforcedStyle: 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?

Metrics/ClassLength:
  CountComments: false  # count full line comments?
  Max: 100

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

# Checks formatting of special comments
Style/CommentAnnotation:
  Keywords:
    - TODO
    - FIXME
    - OPTIMIZE
    - HACK
    - REVIEW

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

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

# 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/EmptyLinesAroundBlockBody:
  EnforcedStyle: no_empty_lines
  SupportedStyles:
    - no_empty_lines

Layout/EmptyLinesAroundClassBody:
  EnforcedStyle: no_empty_lines
  SupportedStyles:
    - no_empty_lines

Layout/EmptyLinesAroundModuleBody:
  EnforcedStyle: no_empty_lines
  SupportedStyles:
    - no_empty_lines

Naming/FileName:
  Exclude:
    - '**/Rakefile'
    - '**/Gemfile'
    - '**/Capfile'

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

Style/HashSyntax:
  EnforcedStyle: ruby19
  SupportedStyles:
    - ruby19
    - hash_rockets

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

Metrics/LineLength:
  Max: 80
  AllowURI: true
  Exclude:
    - config/routes.rb


Style/Next:
  # With `always` all conditions at the end of an iteration needs to be
  # replace 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
  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_no_parentheses
  SupportedStyles:
    - require_parentheses
    - require_no_parentheses

Metrics/MethodLength:
  CountComments: false  # count full line comments?
  Max: 10

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

Style/NumericLiterals:
  MinDigits: 5

Metrics/ParameterLists:
  Max: 5
  CountKeywordArgs: true

# Allow safe assignment in conditions.
Style/ParenthesesAroundCondition:
  AllowSafeAssignment: true

Style/PercentLiteralDelimiters:
  PreferredDelimiters:
    '%':  ()
    '%i': ()
    '%q': ()
    '%Q': ()
    '%r': '{}'
    '%s': ()
    '%w': ()
    '%W': ()
    '%x': ()

Naming/PredicateName:
  NamePrefixBlacklist:
    - get_

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

#Style/RegexpLiteral:
#  # The maximum number of (escaped) slashes that a slash-delimited regexp is
#  # allowed to have. If there are more slashes, a %r regexp shall be used.
#  MaxSlashes: 0

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: double_quotes
  SupportedStyles:
    - single_quotes
    - double_quotes

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

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

Layout/SpaceInsideBlockBraces:
  EnforcedStyle: no_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: false

Layout/SpaceInsideHashLiteralBraces:
  EnforcedStyle: no_space
  EnforcedStyleForEmptyBraces: no_space
  SupportedStyles:
    - space
    - no_space

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

Style/TrailingCommaInArguments:
  # If `comma`, the cop requires a comma after the last argument, but only for
  # parenthesized method calls where each argument is on its own line.
  # If `consistent_comma`, the cop requires a comma after the last argument,
  # for all parenthesized method calls with arguments.
  EnforcedStyleForMultiline: no_comma
  SupportedStylesForMultiline:
    - comma
    - consistent_comma
    - no_comma

Style/TrailingCommaInArrayLiteral:
  # If `comma`, the cop requires a comma after the last item in an array,
  # but only when each item is on its own line.
  # If `consistent_comma`, the cop requires a comma after the last item of all
  # non-empty array literals.
  EnforcedStyleForMultiline: no_comma
  SupportedStylesForMultiline:
    - comma
    - consistent_comma
    - no_comma

Style/TrailingCommaInHashLiteral:
  # If `comma`, the cop requires a comma after the last item in a hash,
  # but only when each item is on its own line.
  # If `consistent_comma`, the cop requires a comma after the last item of all
  # non-empty hash literals.
  EnforcedStyleForMultiline: no_comma
  SupportedStylesForMultiline:
    - comma
    - consistent_comma
    - no_comma

# TrivialAccessors doesn't require exact name matches and doesn't allow
# predicated methods by default.
Style/TrivialAccessors:
  ExactNameMatch: false
  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
  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

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

Style/WordArray:
  MinSize: 0

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

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

##################### Rails ##################################

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

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

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

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

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