Add rubocop.yml

.rubocop.yml

@@ -0,0 +1,191 @@
+Rails:
+  Enabled: true
+
+AllCops:
+  Excludes:
+    - "db/schema.rb"
+
+# Bloom: Exclude RSpec and db/schema
+Metrics/BlockLength:
+  Exclude:
+    - "Gemfile"
+    - "Rakefile"
+    - "db/migrate/*.rb"
+    - "**/*.rake"
+    - "spec/**/*.rb"
+
+# Bloom: Exclude RSpec and db/schema
+Metrics/ModuleLength:
+  Exclude:
+    - "Gemfile"
+    - "Rakefile"
+    - "**/*.rake"
+    - "spec/**/*.rb"
+
+# Bloom prefers empty lines on classes
+Layout/EmptyLinesAroundClassBody:
+  EnforcedStyle: empty_lines
+
+# Bloom prefers the literal -> () call
+Style/Lambda:
+  EnforcedStyle: literal
+
+# Bloom prefers space in the literal -> () call
+Layout/SpaceInLambdaLiteral:
+  EnforcedStyle: require_space
+
+# Bloom prefers the () call
+Style/LambdaCall:
+  Enabled: false
+
+# Bloom: hashes/arrays look more readable if indented on the same as the hash literal
+Layout/IndentHash:
+  EnforcedStyle: consistent
+Layout/IndentArray:
+  EnforcedStyle: consistent
+
+Lint/UnusedMethodArgument:
+  Enabled: false
+Lint/UnusedBlockArgument:
+  Enabled: false
+
+# Bloom: Prefer leaving trailing commas, lessens git commits
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: comma
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: comma
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: comma
+
+# Bloom: Frozen literals don't offer that much improvement for the amount of changes
+# we'll need to benefit
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+# Bloom: Too explicit
+Rails/HasManyOrHasOneDependent:
+  Enabled: false
+
+# Bloom: Most methods, like factory_bot factory methods, look more readable
+# when supplying attributes via a hash
+Style/BracesAroundHashParameters:
+  Enabled: false
+
+Metrics/LineLength:
+  Max: 80
+
+Metrics/AbcSize:
+  Max: 20
+
+# Too short methods lead to extraction of single-use methods, which can make
+# the code easier to read (by naming things), but can also clutter the class
+Metrics/MethodLength:
+  Max: 25
+
+# The guiding principle of classes is SRP, SRP can't be accurately measured by LoC
+Metrics/ClassLength:
+  Max: 1500
+
+# Single quotes being faster is hardly measurable and only affects parse time.
+# Enforcing double quotes reduces the times where you need to change them
+# when introducing an interpolation. Use single quotes only if their semantics
+# are needed.
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+# We do not need to support Ruby 1.9, so this is good to use.
+Style/SymbolArray:
+  Enabled: true
+
+# Mixing the styles looks just silly.
+Style/HashSyntax:
+  EnforcedStyle: ruby19_no_mixed_keys
+
+# has_key? and has_value? are far more readable than key? and value?
+Style/PreferredHashMethods:
+  Enabled: false
+
+# String#% is by far the least verbose and only object oriented variant.
+Style/FormatString:
+  EnforcedStyle: percent
+
+Style/CollectionMethods:
+  Enabled: true
+  PreferredMethods:
+    # inject seems more common in the community.
+    reduce: "inject"
+
+# Either allow this style or don't. Marking it as safe with parenthesis
+# is silly. Let's try to live without them for now.
+Style/ParenthesesAroundCondition:
+  AllowSafeAssignment: false
+Lint/AssignmentInCondition:
+  AllowSafeAssignment: false
+
+# A specialized exception class will take one or more arguments and construct the message from it.
+# So both variants make sense.
+Style/RaiseArgs:
+  Enabled: false
+
+# Indenting the chained dots beneath each other is not supported by this cop,
+# see https://github.com/bbatsov/rubocop/issues/1633
+Layout/MultilineOperationIndentation:
+  Enabled: false
+
+# Fail is an alias of raise. Avoid aliases, it's more cognitive load for no gain.
+# The argument that fail should be used to abort the program is wrong too,
+# there's Kernel#abort for that.
+Style/SignalException:
+  EnforcedStyle: only_raise
+
+# Suppressing exceptions can be perfectly fine, and be it to avoid to
+# explicitly type nil into the rescue since that's what you want to return,
+# or suppressing LoadError for optional dependencies
+Lint/HandleExceptions:
+  Enabled: false
+
+Layout/SpaceInsideBlockBraces:
+  # The space here provides no real gain in readability while consuming
+  # horizontal space that could be used for a better parameter name.
+  # Also {| differentiates better from a hash than { | does.
+  SpaceBeforeBlockParameters: false
+
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented
+
+# { ... } for multi-line blocks is okay, follow Weirichs rule instead:
+# https://web.archive.org/web/20140221124509/http://onestepback.org/index.cgi/Tech/Ruby/BraceVsDoEnd.rdoc
+Style/BlockDelimiters:
+  Enabled: false
+
+# do / end blocks should be used for side effects,
+# methods that run a block for side effects and have
+# a useful return value are rare, assign the return
+# value to a local variable for those cases.
+Style/MethodCalledOnDoEndBlock:
+  Enabled: true
+
+# Enforcing the names of variables? To single letter ones? Just no.
+Style/SingleLineBlockParams:
+  Enabled: false
+
+# Shadowing outer local variables with block parameters is often useful
+# to not reinvent a new name for the same thing, it highlights the relation
+# between the outer variable and the parameter. The cases where it's actually
+# confusing are rare, and usually bad for other reasons already, for example
+# because the method is too long.
+Lint/ShadowingOuterLocalVariable:
+  Enabled: false
+
+# Check with yard instead.
+Style/Documentation:
+  Enabled: false
+
+# This is just silly. Calling the argument `other` in all cases makes no sense.
+Naming/BinaryOperatorParameterName:
+  Enabled: false
+
+# There are valid cases, for example debugging Cucumber steps,
+# also they'll fail CI anyway
+Lint/Debugger:
+Enabled: false