Crash after Swift 3 update

[andrealufino]

Hello guys, I'm having a serious problem with Pantry. I didn't change anything from what I had before the update (it's a project that could wait). After this update, Pantry crashes at every pack call. I pack arrays (of every type, even custom structs that conforms to the Storable protocol) and other kind of stuff. Before the update everything was working good, not now.

One of the call is simple as :

Pantry.pack(self, key: pantryKeyCurrentUser)

Here crashes pointing me to this line (number 118 of file JSONWarehouse):

let data = try JSONSerialization.data(withJSONObject: storableDictionary, options: .prettyPrinted)

The error is EXC_BAD_INSTRUCTION (code = EXC_I386_INVOP, subcode = 0x0)

[nickoneill]

Thanks, I'll check this out today

[andrealufino]

Do you have some news?

[nickoneill]

Hey @andrealufino, I don't see any specific problems with this line in swift 3. In fact, it should be safer than previously since we wrap those try blocks to catch errors now.

Does this crash on a device as well as the sim?

[andrealufino]

Yes, it crashes on both.
This is the log into the console :
fatal error: attempt to bridge an implicitly unwrapped optional containing nil

[andreamazz]

Hi @andrealufino
Can you reproduce the issue in the sample project to help debug the issue?

[andrealufino]

I tried, but in the example app everything is working good.
In my project this is the piece of code from which everything goes wrong :

var newsLocal: [News] = [] {
        didSet {
            print("News - News local just update! Now we'll save the new array with Pantry!")
            Pantry.pack(newsLocal, key: pantryKeyNewsLocal)
            print("News - Local news saved with Pantry!")
        }
    }

News is a struct which implements the Storable protocol.

Could be that if the array is empty (or nil) something happens? I don't know, but I can assure you this was working really good with the older version (before Swift 3).

[andreamazz]

Empty arrays are packed correctly, and from the code you posted the array can't be nil (unless you use force unwrapping, but in that case it would bail out earlier)

[andrealufino]

Exactly, that array will never be nil. It comes from the server, but even if I have no news to show, I pass an empty array and not a nil one. The weird thing is that fatal error: attempt to bridge an implicitly unwrapped optional containing nil console log.

[andrealufino]

What if some attribute of the a news object is nil?

[andreamazz]

Yeah, that might be the issue as far as I can tell

[andrealufino]

This thing has changed from previous version, right?

[andreamazz]

Yep, this is due to the JSON serialization.

[andreamazz]

Ok, I was able to reproduce the issue. Let me see if I can fix it.

[andreamazz]

The problem is inherent to Swift 3's Any type, which can hold an optional of nil value. The JSON serializer doesn't play well with a nil value.
You can test this in a playground:

let packet: [String: Int?] = ["one": nil]
let dictionary: [String: Any] = ["packet": packet]

do {
    let data = try JSONSerialization.data(withJSONObject: dictionary, options: .prettyPrinted)
} catch {
    print("error")
}

I'm not sure if reverting to the use of AnyObject in the toDictionary func of the Storable protocol might be the better course of action. It will limit the flexibility of Any, but it would provide a safer API. What do you think @nickoneill?

In the meantime @andrealufino you can use nil coalescing in your toDictionary implementation, providing default values for nullable objects, like so:

struct News: Storable {
    var title = ""
    var body: String? = nil

    init?(warehouse: Warehouseable) {}

    func toDictionary() -> [String: Any] {
        return ["title": title, "body": body]
    }
}

[andrealufino]

In my structures there is no toDictionary() method implementation however and I've never needed it. Could this be another problem? I can assure you everything was working good even without it. This is my News struct :

import Foundation
import Pantry

private let keyImage = "image"
private let keyTitle = "title"
private let keyBody = "body"
private let keyDate = "date"
private let keyUrl = "url"
private let keyType = "type"

// The protocols StorableRawEnum and Storable are provided by the Pantry framework.
// These protocols are useful when you have to permanently store data on disk

enum NewsType: Int, StorableRawEnum {
    case local  = 2
    case global = 1
}

struct News: Storable {

    var image: String!
    var title: String!
    var body: String!
    var date: String!
    var url: String!
    var type: NewsType!

    init?(warehouse: Warehouseable) {

        self.image = warehouse.get(keyImage) ?? ""
        self.title = warehouse.get(keyTitle) ?? ""
        self.body = warehouse.get(keyBody) ?? ""
        self.date = warehouse.get(keyDate) ?? ""
        self.url = warehouse.get(keyUrl) ?? ""
        self.type = warehouse.get(keyType) 
    }

    init(title: String!, body: String!, image: String!, date: String!, url: String!, type: NewsType!) {

        self.title = title
        self.body = body
        self.image = image
        self.date = date
        self.type = type
    }
}

ps: in my opinion is better to keep the Any instead of AnyObject for flexibility reasons adding maybe an assert to make people understand what is causing the problem.