klein-artur

struct Selectables<Data, ID: Hashable, Content>: View where Content: View {
    let data: [Data]
    @Binding var selectedIds: [ID]
    let id: KeyPath<Data, ID>
    let content: (Data, Binding<Bool>) -> Content

    init(_ data: [Data], selectedIds: Binding<[ID]>, id: KeyPath<Data, ID>, @ViewBuilder content: @escaping (Data, Binding<Bool>) -> Content) {
        self.data = data
        self._selectedIds = selectedIds
        self.id = id

klein-artur

extension Result where Failure == ParseError {
    func checkError(messageIfNotError: String, type: ParseErrorType) {
        switch self {
        case .success(_):
            XCTFail(messageIfNotError)
        case let .failure(error):
            if error.type != type {
                XCTFail("Should have thrown \(type.rawValue) but did \(error.type)")
            }
        }

klein-artur

struct AlertAction {
    let title: String
    var role: ButtonRole? = .none
    let action: (() -> Void)
}

struct AlertItem {
    let title: String
    let message: String
    let actions: [AlertAction]

klein-artur

import Foundation
import SwiftUI

struct AlertButton: Identifiable {
    var id: String {
        title
    }

    let title: String
    let style: ButtonRole?

klein-artur

struct RgxResult {
    private let textCheckingResult: NSTextCheckingResult
    private let baseString: String
    
    init(_ result: NSTextCheckingResult, _ baseString: String) {
        self.textCheckingResult = result
        self.baseString = baseString
    }
}

klein-artur

import Cocoa
import RxSwift
import RxCocoa

infix operator <->

func <-> <T>(property: ControlProperty<T>, variable: BehaviorRelay<T>) -> Disposable {
    let bindToUIDisposable = variable.asObservable()
        .bind(to: property)

klein-artur

Find Strings between quotes

(?:")((?:.|\n)*?)(?<!\\)(?:")

The first group will be the string itself. Escaped quotes are ignored.

klein-artur

extension String {
    func localize() -> String {
        return NSLocalizedString(self, comment: "")
    }
    
    func localize(_ args: CVarArg...) -> String {
        return String(format: NSLocalizedString(self, comment: ""), args)
    }
}

klein-artur

Regex to split an url into its parts:

This regex splits an http or https url into its parts.

^(?:(?:(?:(http[s]?):\/\/)(?:([a-zA-Z0-9]+)?\.)?([^:\/\s\?]+\.+[^:\/\s\?]+))?(?:((?:\/[^\/\s]+)*\/)?(?:([\w\-\.]+[^#?\s]+))?)?(#[^#?\s]+)?(?:\?+([^\.\s$]+)?)?)$

Groups

0. Whole match

klein-artur

extension String {
    func substring(from: UInt, length: UInt) -> String {
        if Int(from) >= self.characters.count {
            preconditionFailure("from is out of bounds.")
        }
        if Int(from+length) > self.characters.count {
            preconditionFailure("from and lenght are out of bounds")
        }
        
        let startIndex = self.index(self.startIndex, offsetBy: String.IndexDistance(from))