libshit

.rubocop.yml (9905B)

---

 Layout/BeginEndAlignment: { EnforcedStyleAlignWith: begin }
 Layout/BlockAlignment: { Enabled: false }
 Layout/BlockEndNewline: { Enabled: false }
 Layout/DotPosition: { EnforcedStyle: trailing }
 Layout/EmptyLineAfterGuardClause: { Enabled: false }
 Layout/EmptyLineAfterMagicComment: { Enabled: false }
 Layout/EmptyLineBetweenDefs: { NumberOfEmptyLines: [0,2] }
 Layout/EmptyLines: { Enabled: false } # you're seriously sick, seek help
 Layout/EmptyLinesAroundAccessModifier: { EnforcedStyle: only_before }
 Layout/EmptyLinesAroundAttributeAccessor: { Enabled: false }
 Layout/EmptyLinesAroundClassBody: { Enabled: false } # I like to keep my code readable
 Layout/EmptyLinesAroundExceptionHandlingKeywords: { Enabled: false }
 Layout/EmptyLinesAroundModuleBody: { Enabled: false }
 Layout/FirstArrayElementIndentation: { Enabled: false }
 Layout/HashAlignment: { EnforcedLastArgumentHashStyle: ignore_implicit }
 Layout/HeredocIndentation: { Enabled: false }
 Layout/LineLength: { Max: 85 } # actually 80, but that generates too many warnings. but if I disable this facefucker, ifunlessmodifier wants to create gigantic long lines
 Layout/MultilineArrayBraceLayout: { Enabled: false }
 Layout/MultilineBlockLayout: { Enabled: false } # thank you for being customizable
 Layout/MultilineMethodCallBraceLayout: { Enabled: false }
 Layout/MultilineMethodCallIndentation: { EnforcedStyle: indented_relative_to_receiver }
 Layout/RescueEnsureAlignment: { Enabled: false } # broken in lambdas
 Layout/SpaceAfterComma: { Enabled: false }
 Layout/SpaceAroundOperators: { Enabled: false } # it depends, you idiot
 Layout/SpaceBeforeBlockBraces: { Enabled: false } # space, except for sequel
 Layout/SpaceBeforeComment: { Enabled: false } # I do except when there is no space
 Layout/SpaceInsideArrayLiteralBrackets: { Enabled: false }
 Layout/SpaceInsideBlockBraces: { Enabled: false } # space, except for sequel
 Layout/SpaceInsideHashLiteralBraces: { Enabled: false }
 Lint/AmbiguousBlockAssociation: { Enabled: false }
 Lint/AmbiguousOperator: { Enabled: false }
 Lint/AmbiguousOperatorPrecedence: { Enabled: false } # Ambiguous my ass. Looks like someone failed elementary school.
 Lint/AmbiguousRegexpLiteral: { Enabled: false } # I told you, this is not java you fucking useless piece of fucking shit
 Lint/AssignmentInCondition: { Enabled: false } # this is not pascal FFS
 Lint/ConstantDefinitionInBlock: { Enabled: false } # I've seen ruby code in my life, thank you very much
 Lint/EmptyBlock: { Enabled: false } # .each is not the only method taking a block cocksuckers
 Lint/EmptyWhen: { Enabled: false }
 Lint/InterpolationCheck: { Enabled: false } # guess what... I'm using a single quoted string, because I DO NOT WANT IT TO BE FUCKING INTERPOLATED YOU FUCKING IDIOT. Keep your idiot rules to pajeets who can't code.
 Lint/NonLocalExitFromIterator: { Enabled: false } # what the fuck is your fucking problem
 Lint/RescueException: { Enabled: false }
 Lint/ShadowingOuterLocalVariable: { Enabled: false }
 Lint/UnusedBlockArgument: { Enabled: false }
 Metrics/AbcSize: { Enabled: false } # stfu
 Metrics/BlockLength: { Enabled: false }
 Metrics/BlockNesting: { Enabled: false }
 Metrics/ClassLength: { Enabled: false }
 Metrics/CyclomaticComplexity: { Enabled: false }
 Metrics/MethodLength: { Enabled: false }
 Metrics/ModuleLength: { Enabled: false }
 Metrics/ParameterLists: { Enabled: false }
 Metrics/PerceivedComplexity: { Enabled: false }
 Naming/AccessorMethodName: { Enabled: false } # not everything that starts with a `get_` is an accessor you retard
 Naming/BinaryOperatorParameterName: { Enabled: false } # you can't even configure the name, it can only force the nigger braindead name "other"
 Naming/BlockForwarding: { Enabled: false } # doesn't work well without parentheses
 Naming/HeredocDelimiterNaming: { Enabled: false } # you're retarded beyond help
 Naming/MemoizedInstanceVariableName: { Enabled: false }
 Naming/MethodParameterName: { MinNameLength: 1 }
 Naming/PredicateName: { ForbiddenPrefixes: [is_] } # Do not bark in `has_something?`. Is `is` the same as `has`? Is an apple same as an orange? Is an iceberg the same as a Titanic? Is being a retard who needs to be kept in an asylum is the same as a well functioning member of the society? No, it's not the fucking same thing you fucking piece of idiot retarded shit!
 Naming/VariableNumber: { Enabled: false } # you're worse than autotools' checking whether strstr works in linear time
 Security/Eval: { Enabled: false }
 Security/MarshalLoad: { Enabled: false } # why don't you mark system/spawn at the same time? File.write with a user controlable filename? puts? the script's output might be redirected to shell, and that will execute it. object creation? it might cause memory exhaustion and lead to a DoS.
 Security/Open: { Enabled: false } # I'm not calling Kernel#open, I'm calling my own open you fucking brainlet
 Style/AccessModifierDeclarations: { Enabled: false } # use whatever style makes sense
 Style/AccessorGrouping: { Enabled: false }
 Style/AndOr: { Enabled: false } # they have different precedence you fucking retards
 Style/BarePercentLiterals: { EnforcedStyle: percent_q }
 Style/CaseEquality: { Enabled: false }
 Style/CharacterLiteral: { Enabled: false } # why there isn't a reverse option
 Style/ClassAndModuleChildren: { Enabled: false } # it's not style FFS, the two option mean two completely different things!
 Style/ClassVars: { Enabled: false } # yes, I'm totally gonna type 120x more just to have a tiny little bit saner behavior
 Style/CombinableLoops: { Enabled: false } # this cop should be called PleaseBreakMyCode
 Style/CommentAnnotation: { Enabled: false }
 Style/CommentedKeyword: { Enabled: false }
 Style/DocumentDynamicEvalDefinition: { Enabled: false } # can't you just, you know, read?
 Style/Documentation: { Enabled: false }
 Style/DoubleNegation: { Enabled: false } # hey, don't use this feature, because negative IQ pajeets can misuse it!
 Style/FetchEnvVar: { Enabled: false } # quoting docs: "Suggests ‘ENV.fetch` for the replacement of `ENV[]`. `ENV[]` silently fails and returns `nil` when the environment variable is unset" JESUS FUCKING CHRIST, ENV#[] works like every other [] operator in this fucking language, that's confusing!!!!!!!!111 Don't use it!!!1!!!!11111
 Style/FormatString: { Enabled: false } # it depends which is best, retards
 Style/FormatStringToken: { Enabled: false } # jesus fucking christ, what is your fucking problem
 Style/GlobalVars: { Enabled: false }
 Style/GuardClause: { Enabled: false }
 Style/HashAsLastArrayItem: { EnforcedStyle: no_braces }
 Style/KeywordParametersOrder: { Enabled: false }
 Style/Lambda: { EnforcedStyle: literal }
 Style/MethodDefParentheses: { EnforcedStyle: require_no_parentheses }
 Style/MixinUsage: { Enabled: false }
 Style/ModuleFunction: { EnforcedStyle: extend_self }
 Style/MultilineBlockChain: { Enabled: false } # just why
 Style/MultilineTernaryOperator: { Enabled: false }
 Style/MultipleComparison: { Enabled: false } # yes, I'm totally gonna allocate a fucking array every time I want to write x == a || x == b, because ruby is not fucking slow as is, we have to make it worse and type more, just so some retards fragile ego will be better.
 Style/NestedParenthesizedCalls: { Enabled: false }
 Style/NestedTernaryOperator: { Enabled: false } # do you have negative IQ or what?
 Style/NilComparison: { Enabled: false }
 Style/NonNilCheck: { Enabled: false }
 Style/NumericLiterals: { Enabled: false }
 Style/NumericPredicate: { Enabled: false } # why do you want to turn ruby even more unreadable than brainfuck?!
 Style/OpenStructUse: { Enabled: false } # the only real alternative is reimplementing it yourself with the same semantics...
 Style/OptionalBooleanParameter: { Enabled: false } # shut the fuck up for fucks sake
 Style/ParallelAssignment: { Enabled: false }
 Style/PercentLiteralDelimiters: { Enabled: false } # can't specify multiple good
 Style/PerlBackrefs: { Enabled: false } # why there's no reverse option?
 Style/RedundantHeredocDelimiterQuotes: { Enabled: false } # rubocop: don't write "foo", write 'foo'. Also rubocop: dont't write <<'FOO', write <<FOO which is equivalent to double quoted strings. (ﾉ≧∇≦)ﾉ ﾐ ┸━┸
 Style/RedundantLineContinuation: { Enabled: false } # buggy (warns on `foo \\n  "asd"`)
 Style/RedundantReturn: { AllowMultipleReturnValues: true }
 Style/RescueModifier: { Enabled: false }
 Style/RescueStandardError: { EnforcedStyle: implicit }
 Style/Semicolon: { Enabled: false } # another completely useless check because it warns even when the fucking semicolon is fucking required
 Style/SignalException: { Enabled: false }
 Style/SingleLineMethods: { Enabled: false }
 Style/SpecialGlobalVars: { EnforcedStyle: use_perl_names }
 Style/StabbyLambdaParentheses: { EnforcedStyle: require_no_parentheses }
 Style/StderrPuts: { Enabled: false }
 Style/StringConcatenation: { Enabled: false }
 Style/SymbolArray: { MinSize: 5 }
 Style/TernaryParentheses: { Enabled: false } # require_parentheses_when_complex would be the correct one, but x > 0 is considered a complex expression by this niggeroid crap
 Style/TrailingCommaInArguments: { Enabled: false } # vv
 Style/TrailingCommaInArrayLiteral: { Enabled: false } # whoever came up with the default value for this rule seriously need to see a doctor. Also all built-in styles suck (consistent_comma warns on [a,b,\nc,d], comma warns on [\na,b,\nc,d,\n], and the default no_comma is so braindead that it needs no explanation. Use JSON if you want that shit retard.)
 Style/TrailingCommaInHashLiteral: { Enabled: false } # ^^
 Style/VariableInterpolation: { Enabled: false } # this is not pascal FFS
 Style/WhenThen: { Enabled: false } # fuck you
 
 
 # todo: figure something out about module A; module B; module C shit
 Layout/EndAlignment: { Enabled: false }
 Layout/IndentationWidth: { Enabled: false }
 Style/TrailingBodyOnModule: { Enabled: false }
 
 AllCops:
   NewCops: enable
   TargetRubyVersion: 3.2