wildthink

Bundles

Bundles are folders that the OS treats as one file .app is a bundle .framework is a bundle .bundle is a bundle .a is NOT a bundle

The Bundle API in Foundation is useful for navigating and loading resources inside of a bundle The simplest -- .bundle -- is used to share files and resources. We use .bundles for sharing APIEnvironment files: certificates, plists, etc needed to communicate with our APIs. Bundles can be shared between targets. For example, TestHarness in toolbox copies the API bundles during it's copy bundle phase into the .app bundle's Resources folder. You can load resources from these bundles using Bundle.main.urlForResource:extension: which will return the path to the bundle. You can then use the Bundle(url:) to get a representation of that Bundle. Or alternatively, you can give a bundle an identifier and use the Bundle(identifier:) initializer.

wildthink

command alias objc expression -l objc -O --
command regex swift 's#(.+)#expression -l Swift -O -- defer { CATransaction.flush() }; %1#'

breakpoint set -n AppDelegate.application --one-shot true --auto-continue true
breakpoint command add
swift import Foundation
swift import UIKit
swift import MyApp_tvOS
swift import MyApp_iOS
swift func $printSubviews(of view: UIView) { print(view.perform("recursiveDescription")!) }

wildthink

// https://www.goranbrl.dev/posts/1-grouping/

extension Collection {

    func groupBy<GroupingType: Hashable>(key: (Element) -> (GroupingType)) -> [[Element]] {
        var groups: [GroupingType: [Element]] = [:]
        var groupsOrder: [GroupingType] = []

        forEach { element in
            let key = key(element)

wildthink

Swift Structs vs Parameterized Enums

There seems to be preference for choosing enums with parameters over Structs. Personally I've always been annoyed by inability of different components to extend an "enumerated" set of values, not to mention the extra work to extract enumerated values as needed (but explained here).

Both Swift structs and enums create a namespace that guides autocompletion. But what I really like about using structs is the ability to easily prototypes, instances providing default values.

With the addition of callAsFunction(...) building on prototypes is even easier.

wildthink

// Original: https://gist.github.com/loudmouth/332e8d89d8de2c1eaf81875cfcd22e24
import Foundation

private struct JSONCodingKeys: CodingKey {
    var stringValue: String
    
    init(stringValue: String) {
        self.stringValue = stringValue
    }
    

wildthink

import Foundation

struct Maker {
    var code: () -> Any
    func make<A: Any>() -> A? {
        return code() as? A
    }
}

extension Maker {

wildthink

//
//  Resource.swift
//
//  Copyright (c) 2019 Jason Jobe. All rights reserved.
//  https://gist.github.com/wildthink/567608a37253da877eb6a2f69d7e99fc
//  Inspired by https://bustoutsolutions.github.io/siesta/
//  Created by Jason Jobe on 5/11/19.
//
import Foundation

wildthink

import Foundation
// thanks to https://www.swiftbysundell.com/posts/a-deep-dive-into-grand-central-dispatch-in-swift

/// The FileObjserver watches a single File URL but only if the file exists
/// If the file is removed, you will get a delete event but nothing else
/// thereafter, even if the file is recreated at the same path
public class FileObserver {
    public typealias Event = DispatchSource.FileSystemEvent
    public let url: URL
    public var currentEvent: Event {

wildthink

//
//  DomainContext.swift
//
//  Copyright (c) 2019 Jason Jobe. All rights reserved.
//  https://gist.github.com/wildthink/fa824de45aacc2fed89aae0fe2cf0370
//
//  Created by Jason Jobe on 5/11/15.
//  Derived from Relay.swift
//  Copyright (c) 2015, 2016 Jason Jobe. All rights reserved.
//  https://gist.github.com/wildthink/acfdf82c2625dc73ad6e42d399d91846

wildthink

// https://medium.cobeisfresh.com/accessing-types-from-extensions-in-swift-32ca87ec5190

public protocol Clonable {
    func clone() throws -> Self?
}

public protocol Clonable {
    func clone() throws -> Self
}