JanGorman

@propertyWrapper
struct Expirable<Value: ExpressibleByNilLiteral> {

  let duration: TimeInterval
  private var expirationDate = Date()
  private var innerValue: Value = nil

  private var hasExpired: Bool {
    expirationDate < Date()
  }

JanGorman

extension String {
  var isBlank: Bool {
    return allSatisfy { $0.isWhitespace }
  }
}

JanGorman

let url = URL(string: "https://youtu.be/k0kSc8hHzAM?t=1461")!
UIApplication.shared.open(url, options: [.universalLinksOnly: true]) { (success) in
  if !success {
  // not a universal link or app not installed
    let vc = SFSafariViewController(url: url)
    self.present(vc, animated: true)
  }
}

JanGorman

// Combine app + shared defaults into one
extension UserDefaults {
  static var shared: UserDefaults {
    let combined = UserDefaults.standard
    combined.addSuite(named: "com.schnaub.app")
    return combined
  }
}

// Unit test instance that clears all values before the test is run

JanGorman

func with<T>(_ x: T, _ f: (inout T) -> Void) -> T {
  var value = x
  f(&value)
  return value
}

JanGorman

extension Optional where Wrapped: Collection {
  var nonEmpty: Wrapped? {
    return self?.isEmpty == true ? nil : self
  }
}

struct BillingInfo {
  var name: String
  var vatNumber: String?
}

JanGorman

struct Predicate<Element> {
  private let condition: (Element) -> Bool
  
  func evaluate(for element: Element) -> Bool {
    return condition(element)
  }
}

func <= <Element, T: Comparable>(_ attribute: KeyPath<Element, T>, _ constant: T) -> Predicate<Element> {
  return Predicate(condition: { $0[keyPath: attribute] <= constant })

JanGorman

extension Optional where Wrapped: Collection {
    var isNilOrEmpty: Bool {
        return self?.isEmpty ?? true
    }
}

if textField.text.isNilOrEmpty {
  // No unwraps  
}

JanGorman

// Float comparison
infix operator ==~ : ComparisonPrecedence
func ==~<T> (lhs: T, rhs: T) -> Bool where T: FloatingPoint {
  return lhs == rhs || lhs.nextDown == rhs || lhs.nextUp == rhs
}

// 0 padded numbers
let formatter = NumberFormatter()
formatter.minimumIntegerDigits = 20
formatter.string(for: 30) // 00000000000000000030

JanGorman

extension String {
  // [i]
  subscript(i: Int) -> Character {
    let index = self.index(self.startIndex, offsetBy: i)
    return self[index]
  }
  
  // [i..<j]
  subscript(r: Range<Int>) -> String {
    let i = self.index(self.startIndex, offsetBy: r.lowerBound)