miqu.me

1

/Applications/Xcode.app/Contents/MacOS/Xcode -ShowDVTDebugMenu YES

1

DEVELOPER_DIR=/Applications/Xcode.app xcrun swift -frontend -primary-file "/project/path/myfile.swift" "-module-name" "Peak" "-Onone" "-DDEBUG" "-sdk" "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS10.3.sdk" "-target" "arm64-apple-ios8.0" 

1

protocol AutoObjCBridgeable {}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

enum CheckoutOption {
    case creditCard(given: Int)
    case paypal(String)
}

struct ShoppingCart  {
    var items: [String]
    var checkoutOption: CheckoutOption?

    init(items: [String], checkoutOption: CheckoutOption? = nil) {
        self.items = items
        self.checkoutOption = checkoutOption
    }
}

1
2

extension ShoppingCart : AutoObjCBridgeable {}
extension CheckoutOption : AutoObjCBridgeable {}

1
2
3
4
5
6
7

// Bridging for structs
{% for type in types.implementing.AutoObjCBridgeable|struct %}
{% endfor %}

// Bridging of enums
{% for enum in types.implementing.AutoObjCBridgeable|enum %}
{% endfor %}

1
2
3
4
5
6

{% for type in types.implementing.AutoObjCBridgeable|struct %}
@objc(XYZ{{type.name}})
class _ObjC{{type.name}} : NSObject {
    // TODO
}
{% endfor %}

1
2

struct EmptyStruct : AutoObjCBridgeable {
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

@objc(XYZEmptyStruct)
class _ObjCEmptyStruct : NSObject {
    private (set) var emptyStruct: EmptyStruct

    // Initializer to be used from Swift code
    init(emptyStruct: EmptyStruct) {
        self.emptyStruct = emptyStruct
    }

    // Initializer to be used from ObjC code
    override init(){
        self.emptyStruct = EmptyStruct()
    }
}

1
2
3
4

struct StructWithSwiftProperties : AutoObjCBridgeable {
    let name: String
    let count: Int
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

@objc(XYZStructWithSwiftProperties)
class _ObjCStructWithSwiftProperties : NSObject {
    private (set) var structWithSwiftProperties: StructWithSwiftProperties

    // Initializer to be used from Swift code
    init(structWithSwiftProperties: StructWithSwiftProperties) {
        self.structWithSwiftProperties = structWithSwiftProperties
    }

    // Initializer to be used from ObjC code
    init(
        name: String,
        count: Int,
        valid: Bool,
        mutableValid: Bool,
        someStuff: [String]
    ){
        self.structWithSwiftProperties = StructWithSwiftProperties(
                name: name,
                count: count,
                valid: valid,
                mutableValid: mutableValid,
                someStuff: someStuff
            )
    }

    var name : String {
        return self.structWithSwiftProperties.name
    }

    var count : Int {
        return self.structWithSwiftProperties.count
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

{% if variable.type.kind != "struct" and variable.type.kind != "enum" %}
    // Forwarding property for native types
    var {{variable.name}} : {{variable.typeName}}
    {
        get {
            return self.{{type.name|lowerFirstWord}}.{{variable.name}}
        }
        {% if variable.isMutable %}
        set {
            self.{{type.name|lowerFirstWord}}.{{variable.name}} = newValue
        }
        {% endif %}
    }
{% endif %}

1
2
3
4
5
6

private (set) var {{type.name|lowerFirstWord}}: {{type.name}}

// Initializer to be used from Swift code
init({{type.name|lowerFirstWord}}: {{type.name}}) {
    self.{{type.name|lowerFirstWord}} = {{type.name|lowerFirstWord}}
}

1
2
3
4

enum OtherEnum : AutoObjCBridgeable {
    case a
    case b(EmptyStruct)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

@objc(XYZOtherEnum)
class _ObjCOtherEnum : NSObject {
    private (set) var otherEnum: OtherEnum

    // Initializer for Swift code
    init(value: OtherEnum) {
        self.otherEnum = value
    }

    // Initializer for Objective-C code
    init(caseValue: Any) {
        if let _ = caseValue as? _ObjCOtherEnumA {
            self.otherEnum = .a
        } else if let caseValue = caseValue as? _ObjCOtherEnumB {
            self.otherEnum = .b(caseValue.value1.emptyStruct)
        } else {
            preconditionFailure("Value \(caseValue) is not compatible with cases of OtherEnum")
        }
    }
}

// A case of OtherEnum
@objc(XYZOtherEnumA)
class _ObjCOtherEnumA : NSObject {

}

// A case of OtherEnum
@objc(XYZOtherEnumB)
class _ObjCOtherEnumB : NSObject {
    let value1 : _ObjCEmptyStruct

    init(value1 : _ObjCEmptyStruct)
    {
        self.value1 = value1
    }
}

1
2
3
4
5
6

// Setting for last Xcode
OTHER_SWIFT_FLAGS_XCODE_0820 = //if any>
// Setting for Xcode Beta
OTHER_SWIFT_FLAGS_XCODE_0830 = -enable-bridging-pch
// Switch configuration based on Xcode version
OTHER_SWIFT_FLAGS = $(OTHER_SWIFT_FLAGS_XCODE_$(XCODE_VERSION_MINOR))

1
2
3
4
5
6

#!/bin/sh
# Script for .git/hooks/post-checkout
set -e
osascript -e 'quit app "Xcode"'
pod install
open -a Xcode

1
2
3
4
5

#!/bin/sh
set -e
xcodebuild -arch x86_64 -sdk iphonesimulator10.2 -derivedDataPath ".build" -scheme myScheme

ios-sim launch --devicetypeid com.apple.CoreSimulator.SimDeviceType.iPhone-6-Plus .build/Build/Products/Debug-iphonesimulator/myapp.app

1

'sharedApplication' is unavailable: not available on iOS (App Extension) - Use view controller based solutions where appropriate instead.

1

@property(class, nonatomic, readonly) UIApplication *sharedApplication NS_EXTENSION_UNAVAILABLE_IOS("Use view controller based solutions where appropriate instead.");

1
2

@available(iOSApplicationExtension, unavailable)
open class var shared: UIApplication { get }

1
2
3
4
5
6

Pod::Spec.new do |s|
  s.name             = "MyLibrary"
  # Omitting metadata stuff and deployment targets

  s.source_files = 'MyLibrary/*.{m,h}'
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Pod::Spec.new do |s|
  s.name             = "MyLibrary"
  # Omitting metadata stuff and deployment targets
  s.default_subspec = 'Core'

  s.subspec 'Core' do |core|
    core.source_files = 'MyLibrary/*.{m,h}'
  end

  s.subspec 'AppExtension' do |ext|
    ext.source_files = 'MyLibrary/*.{m,h}'
    # For app extensions, disabling code paths using unavailable API
    ext.pod_target_xcconfig = { 'GCC_PREPROCESSOR_DEFINITIONS' => 'MYLIBRARY_APP_EXTENSIONS=1' }
  end
end

1
2
3
4
5
6
7
8
9
10
11
12

abstract_target 'App' do
  # Shared pods between App and extension, compiled with same preprocessor macros
  pod 'AFNetworking'

  target 'MyApp' do
    pod 'MyLibrary/Core'
  end

  target 'MyExtension' do
    pod 'MyLibrary/AppExtension'
  end
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

import Foundation
import PlaygroundSupport

PlaygroundPage.current.needsIndefiniteExecution = true

typealias RawLocalizationData = [[String:String]]

struct Entry {
    var key: String
    var value: String
}

struct Localization {
    var languageKey: String
    var entries: [Entry]
}

extension Localization {
    func export() -> [String] {
        return entries.map { entry in
            let value = entry.value.characters.count > 0 ? entry.value : "NOT_TRANSLATED"
            return "\"\(entry.key)\" = \"\(value)\";"
        }
    }
}

func findLanguages(in data: RawLocalizationData) -> [String] {
    guard let firstEntry = data.first else { return [] }
    assert(firstEntry["key"] != nil)
    let languages = firstEntry.keys.filter { $0 != "key" }
    return languages.map { $0 }
}

func parse(_ data: RawLocalizationData) -> [Localization] {
    let languages = findLanguages(in: data)
    var localizations = [String:Localization]()

    for entry in data {
        let key = entry["key"] ?? "__ERROR__NO_KEY__"
        let values = languages.map { (language: $0, entry: Entry(key: key, value: entry[$0]!)) }
        for value in values {
            var localization = localizations[value.language] ?? Localization(languageKey: value.language, entries: [])
            localization.entries.append(value.entry)
            localizations[value.language] = localization
        }
    }

    return localizations.values.map { $0 }
}

func write(_ localizations: [Localization]) {
    for localization in localizations {
        print(localization.export().joined(separator: "\n"))
    }
}

let spreadsheetURL = URL(string: "https://sheetsu.com/apis/v1.0/a96943d37c32", relativeTo: nil)!

let session = URLSession.shared
let task = session.dataTask(with: spreadsheetURL) { data, response, error in
    guard let data = data else { print("Error"); return }

    let json = try? JSONSerialization.jsonObject(with: data, options: []) as! RawLocalizationData
    let localizations = parse(json ?? [])
    write(localizations)

    PlaygroundPage.current.finishExecution()
}

task.resume()

1
2
3
4
5
6
7
8
9
10
11
12
13

protocol Task {
  func execute()
}

class Scheduler {
  func schedule(_ task: Task, every: TimeInterval) {
    // Schedule and save task to run every x seconds
  }

  func run(with date: Date) {
    // Actually perform the calculations and fire due tasks
  }
}

1
2
3

let futureDate: Date // Calculate your future date here

TUDelorean.timeTravel(to: futureDate)

1

TUDelorean.backToThePresent()

1
2
3

#if MYFLAG
// do stuff
#endif

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

//  AppDelegate.m
#import 

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
  [[FBSDKApplicationDelegate sharedInstance] application:application
    didFinishLaunchingWithOptions:launchOptions];
  // Add any custom logic here.
  return YES;
}

- (BOOL)application:(UIApplication *)application openURL:(NSURL *)url sourceApplication:(NSString *)sourceApplication annotation:(id)annotation {
  BOOL handled = [[FBSDKApplicationDelegate sharedInstance] application:application
    openURL:url
    sourceApplication:sourceApplication
    annotation:annotation
  ];
  // Add any custom logic here.
  return handled;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// Respond to URI scheme links
- (BOOL)application:(UIApplication *)application openURL:(NSURL *)url sourceApplication:(NSString *)sourceApplication annotation:(id)annotation {
    // pass the url to the handle deep link call
    [[Branch getInstance] handleDeepLink:url];

    // do other deep link routing for the Facebook SDK, Pinterest SDK, etc
    return YES;
}

// Respond to Universal Links
- (BOOL)application:(UIApplication *)application continueUserActivity:(NSUserActivity *)userActivity restorationHandler:(void (^)(NSArray *restorableObjects))restorationHandler {
    BOOL handledByBranch = [[Branch getInstance] continueUserActivity:userActivity];

    return handledByBranch;
}

1

label.text = @"not-localized";

1

label.text = NSLocalizedString(@"not-localized", nil);

1
2
3
4
5

if #available(iOS 8, *, *) {
  self.view.convertPoint(.Zero, toCoordinateSpace:anotherView)
} else {
  self.view.convertPoint(CGPointZero, toView:anotherView)
}

1
2
3
4
5
6
7
8

//Assume you have a macro that determines OS version, like MQG_OSVERSION_IOS7
//Mark the code with the macro, doing nothing, just where you are doing a workaround that needs to
//be reviewed when you drop iOS7 support
{
  (void)MQG_OSVERSION_IOS7;
  // Do your stuff, which only is needed under iOS7, but you still do for all OS versions
  // like implementing a delegate method that is not needed for iOS8 or greater, etc
}

1
2

brew install cmake
brew install ninja

1
2
3
4
5
6
7
8
9
10

 mkdir apple
 git clone git@github.com:apple/swift.git swift
 git clone git@github.com:apple/swift-llvm.git llvm
 git clone git@github.com:apple/swift-clang.git clang
 git clone git@github.com:apple/swift-lldb.git lldb
 git clone git@github.com:apple/swift-cmark.git cmark
 git clone git@github.com:apple/swift-llbuild.git llbuild
 git clone git@github.com:apple/swift-package-manager.git swiftpm
 git clone git@github.com:apple/swift-corelibs-xctest.git
 git clone git@github.com:apple/swift-corelibs-foundation.git

1

./swift/utils/build-script

1
2
3
4

cd build/Ninja-DebugAssert/swift-macosx-x86_64/bin
./swift --version
#Swift version 2.2-dev (LLVM 46be9ff861, Clang 4deb154edc, Swift c959ce2c83)
#Target: x86_64-apple-macosx10.9

1
2
3

gem install git_stats
cd 
git_stats generate

1
2
3

brew install gource
cd 
gource

1

git log --reverse

1
2

brew install sloccount
sloccount 

1
2
3
4
5

func animation() {
    view.transform = CGAffineTransformMakeScale(0.5, 0.5)
}

UIView.animateWithDuration(0.4, animations: animation)

1
2
3
4
5

let animation {
    view.transform = CGAffineTransformMakeScale(0.5, 0.5)
}

UIView.animateWithDuration(0.4, animations: animation)

1
2

/// If `self == nil`, returns `nil`.  Otherwise, returns `f(self!)`.
    func map<U>(f: @noescape (T) -> U) -> U?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// Map for... mapping. You might be surprised how many times you might need this simple concept

struct MyDataModel {
  // Your app model values
}

class MyViewModel {
  init(model: Model) {
      self.model = model
  }
  // ViewModel logic/presentation values
  private let model: MyDataModel
}

let models: [MyDataModel] //Read from somewhere, maybe DB or remote
let viewModels = models.map(MyViewModel.init)

1
2
3
4

// Reduce instead of loops. Useful when finding aggregate information
let anySubViewEmpty: Bool = self.subviews.reduce(false) { empty, view
     return empty || CGRectEqualToRect(view.frame, CGRectZero)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// Flatmap with optionals. For example parsing some model array and every parse operation can fail, and it's described with a failable initialializer.

struct MyDataModel {
  // Model values
}

extension MyDataModel {
  init?(json: JSON) {
      // Parsing
  }
}

let jsonItems: [JSON] // Fetched from a remote server
// flatMap in Swift 2.0 has special knowledge of optionals, we take advantage of that
let parsedModels = jsonItems.flatMap(MyDataModel.init)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// Map on optionals

struct User {
    let name: String
    let nickname: String?
}

class UserViewModel {
    init(user: User) {
        self.user = user
    }

    var displayName: String {
        func formatNickName(nickName: String) -> String {
            return "Known as \(nickName)"
        }

        // Here we avoid if let by taking advantage of map and nil coalescing operator.
        // Specifies intent with less noise
        return self.user.nickname.map(formatNickName) ?? ""
    }

    private let user: User
}

1
2
3
4
5

// Map instead of loops
let views: [UIView] = // Fill array as needed
views.map { self.addSubview($0) }
// To suppress compiler warning
_ = views.map { self.addSubview($0) }

1
2
3
4
5
6
7
8
9
10
11

// Converts number to string if it is valid
let toValidString: Int -> String? = { number in
    guard number < 10 else { return nil }
    return "Number is small: \(number)"
}

// Converts number to number if it's even
let toEvenNumber: Int -> Int? = { number in
    guard number % 2 == 0 else { return nil }
    return number
}

1
2
3
4
5
6
7

func bind<A,B>(from: A, transform: A->B?) -> B? {
  if let from = from {
      return transform(from)
  }

  return nil
}

1
2
3
4
5

// Outputs "Number is small: 2"
bind(bind(2, transform: toEvenNumber), transform: toValidString)

// Outputs nil
bind(bind(20, transform: toEvenNumber), transform: toValidString)

1
2
3
4

// Bind operator, also called 'flatmap'
func >>-<A,B>(from: A?, transform: A->B?) -> B? {
    return bind(from, transform: transform)
}

1
2
3
4
5

// Outputs "Number is small: 2"
2 >>- toEvenNumber >>- toValidString

// Outputs nil
20 >>- toEvenNumber >>- toValidString

miqu.me

My top 5 must-have technical books

The Pragmatic Programmer: From journeyman to master

The Art of Unit Testing

Seven Languages in Seven Weeks

Domain-Driven Design

The Algorithm Design Manual

Fixing autocompletion on mixed Objective-C and Swift projects

The issue

Bridging header imports

How to debug

Conclusion

Automatic bridging from Swift to Objective-C using Sourcery

About Sourcery

Building the template

Structs vs enums

Bridging an empty struct

Bridging simple enumerations

Conclusion

Build settings depending on Xcode version

Reducing the pain of git bisect with Xcode

Pain points

Reducing the pain

Automate pod install

Automate build and run

Repository discipline

Use bisect

App extensions, Xcode and Cocoapods, OMG!

TL;DR

Unavailable API for App extensions

Libraries using unavailable API for extensions

Enter CocoaPods

What changed?

Solutions

Example

A note about Swift

Easy localization management with Google spreadsheets

The minimal CMS

The spreadsheet

Sheetsu

The script

Caveats

Controlling time in the app

Foundation and dates

Time travel

Conclusion

Knowing when to delete code

Short-lived code

Legacy code

Refactoring vs Rewriting

Clean after yourself

Xcode 8: New build settings and analyzer improvements

Analyzer improvements

‘Misuse of null’ or CLANG_ANALYZER_NONNULL

New setting: CLANG_ANALYZER_OBJC_DEALLOC

New build settings

New setting: SWIFT_ACTIVE_COMPILATION_CONDITIONS

New settings: SWIFT_SUPPRESS_WARNINGS and SWIFT_TREAT_WARNINGS_AS_ERRORS

EMBEDDED_CONTENT_CONTAINS_SWIFT is deprecated

XCConfig files

Dear SDK developer

Documentation

Documentation!

Documentation!!

Please, open source your SDK

Changelogs

Version migration documentation

Your SDK is not the only one

Xcode 7.3 analyzer improvements

New analyzer settings

CLANG_ANALYZER_NONNULL and CLANG_ANALYZER_OBJC_GENERICS

CLANG_ANALYZER_LOCALIZABILITY

Transitioning iOS versions

Long-term projects

Fragmentation

Transitioning iOS versions gracefully

SDK use

Treat deprecated APIs as errors to resolve

At runtime, check for OS versions

ObjC: Mark legacy code paths with macros