swiftlint.yml

# SwiftLint file LS1 TUM
# Created by Paul Schmiedmayer on 08/16/18.
# Copyright © 2019 Paul Schmiedmayer. All rights reserved.
# The opt_in_rules also include all rules that are enabled by default to provide a good overview of all rules.

included:
  - Themis

disabled_rules:
  - discouraged_optional_collection # TODO: Enable as soon as https://github.com/realm/SwiftLint/issues/2298 is closed.
    # Prefer empty collection over optional collection.
  - leading_whitespace
    # Files should not contain leading whitespace.
  - trailing_comma
    # Trailing commas in arrays and dictionaries should be avoided/enforced.
  - vertical_whitespace_opening_braces
    # warn against empty lines after opening braces.
  - multiline_parameters_brackets
    # warn against multiline function definition parameters with surrounding brackets without newline.
  - multiple_closures_with_trailing_closure
    # Trailing closure syntax should not be used when passing more than one closure argument.
  - file_name
    # Validating that file names contain the name of a type or extension declared in the file (if any).
  - multiline_arguments
    # Arguments should be either on the same line, or one per line.

opt_in_rules:
  - block_based_kvo
    # Prefer the new block based KVO API with keypaths when using Swift 3.2 or later.
  - class_delegate_protocol
    # Delegate protocols should be class-only so they can be weakly referenced.
  - closing_brace
    # Closing brace with closing parenthesis should not have any whitespaces in the middle.
  - closure_body_length
    # Closure bodies should not span too many lines.
    # See closure_body_length below for the exact configuration.
  - closure_end_indentation
    # Closure end should have the same indentation as the line that started it.
  - closure_parameter_position
    # Closure parameters should be on the same line as opening brace.
  - closure_spacing
    # Closure expressions should have a single space inside each brace.
  - colon
    # Colons should be next to the identifier when specifying a type and next to the key in dictionary literals.
  - comma
    # There should be no space before and one after any comma.
  - compiler_protocol_init
    # The initializers declared in compiler protocols such as ExpressibleByArrayLiteral shouldn't be called directly.
  - conditional_returns_on_newline
    # Conditional statements should always return on the next line
  - contains_over_first_not_nil
    # Prefer `contains` over `first(where:) != nil`
  - control_statement
    # if, for, guard, switch, while, and catch statements shouldn't unnecessarily wrap their conditionals or arguments in parentheses.
  - convenience_type
    # Types used for hosting only static members should be implemented as a caseless enum to avoid instantiation.
  - cyclomatic_complexity
    # Complexity of function bodies should be limited.
  - discarded_notification_center_observer
    # When registering for a notification using a block, the opaque observer that is returned should be stored so it can be removed later.
  - discouraged_direct_init
    # Discouraged direct initialization of types that can be harmful. e.g. UIDevice(), Bundle()
  - discouraged_optional_boolean
    # Prefer non-optional booleans over optional booleans.
  - dynamic_inline
    # Avoid using 'dynamic' and '@inline(__always)' together.
  - empty_count
    # Prefer checking `isEmpty` over comparing `count` to zero.
  - empty_enum_arguments
    # Arguments can be omitted when matching enums with associated types if they are not used.
  - empty_parameters
    # Prefer () -> over Void ->.
  - empty_parentheses_with_trailing_closure
    # When using trailing closures, empty parentheses should be avoided after the method call.
  - empty_string
    # Prefer checking `isEmpty` over comparing string to an empty string literal.
  - fatal_error_message
    # A fatalError call should have a message.
  - file_length
    # Files should not span too many lines.
    # See file_length below for the exact configuration.
  - first_where
    # Prefer using ``.first(where:)`` over ``.filter { }.first` in collections.
  - for_where
    # where clauses are preferred over a single if inside a for.
  - force_cast
    # Force casts should be avoided.
  - force_try
    # Force tries should be avoided.
  - force_unwrapping
    # Force unwrapping should be avoided.
  - function_body_length
    # Functions bodies should not span too many lines.
    # See function_body_length below for the exact configuration.
  - function_parameter_count
    # Number of function parameters should be low.
    # See function_parameter_count below for the exact configuration.
  - generic_type_name
    # Generic type name should only contain alphanumeric characters, start with an uppercase character and span between 1 and 20 characters in length.
  - identifier_name
    # Identifier names should only contain alphanumeric characters and start with a lowercase character or should only contain capital letters.
    # In an exception to the above, variable names may start with a capital letter when they are declared static and immutable.
    # Variable names should not be too long or too short. Excluded names are listed below.
  - implicit_getter
    # Computed read-only properties and subscripts should avoid using the get keyword.
  - implicit_return
    # Prefer implicit returns in closures.
  - implicitly_unwrapped_optional
    # Implicitly unwrapped optionals should be avoided when possible.
  - inert_defer
    # If defer is at the end of its parent scope, it will be executed right where it is anyway.
  - is_disjoint
    # Prefer using Set.isDisjoint(with:) over Set.intersection(_:).isEmpty.
  - joined_default_parameter
    # Discouraged explicit usage of the default separator.
  - large_tuple
    # Tuples shouldn't have too many members. Create a custom type instead.
    # See large_tuple below for the exact configuration.
  - legacy_cggeometry_functions
    # CGGeometry: Struct extension properties and methods are preferred over legacy functions
  - legacy_constant
    # Struct-scoped constants are preferred over legacy global constants (CGSize, CGRect, NSPoint, ...).
  - legacy_constructor
    # Swift constructors are preferred over legacy convenience functions (CGPointMake, CGSizeMake, UIOffsetMake, ...).
  - line_length
    # Lines should not span too many characters.
    # See line_length below for the exact configuration.
  - literal_expression_end_indentation
    # Array and dictionary literal end should have the same indentation as the line that started it.
  - mark
    # MARK comment should be in valid format. e.g. '// MARK: ...' or '// MARK: - ...'
  - modifier_order
    # Modifier order should be consistent.
  - multiline_function_chains
    # Chained function calls should be either on the same line, or one per line.
  - multiline_parameters
    # Functions and methods parameters should be either on the same line, or one per line.
  - nesting
    # Types and statements should only be nested to a certain level deep.
    # See nesting below for the exact configuration.
  - nimble_operator
    # Prefer Nimble operator overloads over free matcher functions.
  - no_fallthrough_only
    # Fallthroughs can only be used if the case contains at least one other statement.
  - notification_center_detachment
    # An object should only remove itself as an observer in deinit.
  - object_literal
    # Prefer object literals over image and color inits.
  - opening_brace
    # Opening braces should be preceded by a single space and on the same line as the declaration.
  - operator_usage_whitespace
    # Operators should be surrounded by a single whitespace when they are being used.
  - operator_whitespace
    # Operators should be surrounded by a single whitespace when defining them.
  - overridden_super_call
    # Some overridden methods should always call super
  - pattern_matching_keywords
    # Combine multiple pattern matching bindings by moving keywords out of tuples.
  - private_action
    # IBActions should be private.
  - private_outlet
    # IBOutlets should be private to avoid leaking UIKit to higher layers.
  - private_over_fileprivate
    # Prefer private over fileprivate declarations.
  - private_unit_test
    # Unit tests marked private are silently skipped.
  - prohibited_super_call
    # Some methods should not call super (
      # NSFileProviderExtension: providePlaceholder(at:completionHandler:)
      # NSTextInput doCommand(by:)
      # NSView updateLayer()
      # UIViewController loadView())
  - protocol_property_accessors_order
    # When declaring properties in protocols, the order of accessors should be get set.
  - redundant_discardable_let
    # Prefer _ = foo() over let _ = foo() when discarding a result from a function.
  - redundant_nil_coalescing
    # nil coalescing operator is only evaluated if the lhs is nil, coalescing operator with nil as rhs is redundant
  - redundant_optional_initialization
    # Initializing an optional variable with nil is redundant.
  - redundant_set_access_control
    # Property setter access level shouldn't be explicit if it's the same as the variable access level.
  - redundant_string_enum_value
    # String enum values can be omitted when they are equal to the enumcase name.
  - redundant_type_annotation
    # Variables should not have redundant type annotation
  - redundant_void_return
    # Returning Void in a function declaration is redundant.
  - return_arrow_whitespace
    # Return arrow and return type should be separated by a single space or on a separate line.
  - shorthand_operator
    # Prefer shorthand operators (+=, -=, *=, /=) over doing the operation and assigning.
  - sorted_first_last
    # Prefer using `min()`` or `max()`` over `sorted().first` or `sorted().last`
  - statement_position
    # Else and catch should be on the same line, one space after the previous declaration.
  - switch_case_alignment
    # Case statements should vertically align with their enclosing switch statement, or indented if configured otherwise.
  - syntactic_sugar
    # Shorthand syntactic sugar should be used, i.e. [Int] instead of Array.
  - todo
    # TODOs and FIXMEs should be resolved.
  - trailing_newline
    # Files should have a single trailing newline.
  - trailing_semicolon
    # Lines should not have trailing semicolons.
  - trailing_whitespace
    # Lines should not have trailing whitespace.
    # Ignored lines are specified below.
  - type_body_length
    # Type bodies should not span too many lines.
    # See large_tuple below for the exact configuration.
  - type_name
    # Type name should only contain alphanumeric characters, start with an uppercase character and span between 3 and 40 characters in length.
    # Excluded types are listed below.
  - unavailable_function
    # Unimplemented functions should be marked as unavailable.
  - unneeded_break_in_switch
    # Avoid using unneeded break statements.
  - unneeded_parentheses_in_closure_argument
    # Parentheses are not needed when declaring closure arguments.
  - unused_closure_parameter
    # Unused parameter in a closure should be replaced with _.
  - unused_enumerated
    # When the index or the item is not used, .enumerated() can be removed.
  - unused_optional_binding
    # Prefer != nil over let _ =
  - valid_ibinspectable
    # @IBInspectable should be applied to variables only, have its type explicit and be of a supported type
  - vertical_parameter_alignment
    # Function parameters should be aligned vertically if they're in multiple lines in a declaration.
  - vertical_parameter_alignment_on_call
    # Function parameters should be aligned vertically if they're in multiple lines in a method call.
  - vertical_whitespace
    # Limit vertical whitespace to a single empty line.
    # See vertical_whitespace below for the exact configuration.
  - void_return
    # Prefer -> Void over -> ().
  - weak_delegate
    # Delegates should be weak to avoid reference cycles.
  - xctfail_message
    # An XCTFail call should include a description of the assertion.
  - yoda_condition
    # The variable should be placed on the left, the constant on the right of a comparison operator.
  - collection_alignment
    # Validate that all elements in a collection literal are aligned vertically.
  - identical_operands
    # Validate that operands are different expressions in comparisons.
  - toggle_bool
    # suggests using someBool.toggle() over someBool = !someBool. Requires Swift 4.2.
  - multiline_literal_brackets
    # warn against multiline literal arrays & dictionaries with surrounding brackets without newline.
  - vertical_whitespace_closing_braces
    # warn against empty lines before closing braces.
  - legacy_hashing
    # encourage the use of Swift 4.2's new hashing interface.
  - duplicate_imports
    # prevent importing the same module twice.
  - unused_setter_value
    # validate that setter arguments are used in properties.
  - no_space_in_method_call
    # validate that there're no spaces between the method name and parentheses in a method call.
  - contains_over_filter_count
    #  warn against using expressions like filter(where:).count > 0 instead of contains(where:).
  - contains_over_filter_is_empty
    # warn against using expressions like filter(where:).isEmpty instead of contains(where:).
  - empty_collection_literal
    # prefer using isEmpty to comparison to [] or [:].

excluded: # paths to ignore during linting. Takes precedence over `included`.
  - Carthage
  - ./*/Carthage
  - ./*/*/Carthage
  - ./*/*/*/Carthage
  - ./*/*/*/*/Carthage
  - ./*/*/*/*/*/Carthage
  - Pods
  - ./*/Pods
  - ./*/*/Pods
  - ./*/*/*/Pods
  - ./*/*/*/*/Pods
  - ./*/*/*/*/*/Pods
  - .build
  - ./*/.build
  - ./*/*/.build
  - ./*/*/*/.build
  - ./*/*/*/*/.build
  - ./*/*/*/*/*/.build
  - R.generated.swift
  - ./*/R.generated.swift
  - ./*/*/R.generated.swift
  - ./*/*/*/R.generated.swift
  - ./*/*/*/*/R.generated.swift
  - ./*/*/*/*/*/R.generated.swift

closure_body_length: # Closure bodies should not span too many lines.
  - 25 # warning - default: 20
  - 100 # error - default: 100 - default by iPraktikum: 25

file_length: # Files should not span too many lines.
  - 500 # warning - default: 400
  - 500 # error - default: 1000

function_body_length: # Functions bodies should not span too many lines.
  - 50 # warning - default: 40
  - 50 # error - default: 100

function_parameter_count: # Number of function parameters should be low.
  - 5 # warning - default: 5
  - 5 # error - default: 8

identifier_name:
  min_length:
    warning: 3
    error: 0
  allowed_symbols: "_"
  excluded: # excluded names
    - id
    - ok
    - or

large_tuple: # Tuples shouldn't have too many members. Create a custom type instead.
  - 2 # warning - default: 2
  - 2 # error - default: 3

line_length: # Lines should not span too many characters.
  warning: 150 # default: 120
  error: 150 # default: 200
  ignores_comments: true # default: false
  ignores_urls: true # default: false
  ignores_function_declarations: false # default: false
  ignores_interpolated_strings: true # default: false

nesting: # Types should be nested at most 2 level deep, and statements should be nested at most 5 levels deep.
  type_level:
    warning: 2 # warning - default: 1
  statement_level:
    warning: 5 # warning - default: 5

type_body_length: # Type bodies should not span too many lines.
  - 250 # warning - default: 200
  - 250 # error - default: 200

type_name:
  excluded: # excluded names
    - ID

trailing_whitespace:
  ignores_empty_lines: true # default: false
  ignores_comments: true # default: false

vertical_whitespace: # Limit vertical whitespace to a single empty line.
  max_empty_lines: 2 # warning - default: 1

cyclomatic_complexity:
  ignores_case_statements: true # https://stackoverflow.com/a/51221993/7074664