This allows any object, that conforms to the protocol, the ability to extract values like a dictionary. The only thing that is required is for the object to implement the subscript method: subscript(key: KeyType)

Addresses https://github.com/utahiosmac/Marshal/issues/68 & https://github.com/utahiosmac/Marshal/issues/71

The use case is when you have an array of objects but not all the objects successfully initialize. Instead of throwing out all the objects, only throw out the ones that didn't succeed.

I'm trying to marshal a property like:

var arrayOfArrayOfThings: [[Thing]]? 
// ... later on ...
arrayOfArray = try object.value(for: "arrayOfArrayOfThings") 

Where Thing is a Unmarshaling. But I get a No 'value' candidates produce the expected contextual result type '[[Thing]]?'. I tried defining extensions to MarshableObject.value that return [[A]] but got stuck. It seems like for Array<Array<A>> Swift doesn't recognize the inner Array<A> type as a ValueType?

Hi, I really like your approach with Marshal and I wanted to implement it in my project. However, I'm currently using core Data and my objects are NSManagedObjects.

I'm trying to find a way to coexist Marshal and Core Data, but I haven't found any working solution yet. Did you already tried something similar?

Thanks a lot

Hi,

I see a lot of issues around Cocoapods right now, and it stems from people not actually being able to access the podspec, without specifying the git url. In order to fix this then @psychoticidiot needs to run pod trunk push Marshal.podspec.

This will release version 1.2.3 to cocoapods.org, and can then be found with a simple `pod 'Marshal', '~> 1.2'.

Right now you have to do: pod 'Marshal', :git => 'https://github.com/utahiosmac/Marshal.git'.

I hope this clarifies things. If you want, you can add me as a maintainer of the pod, and I'll make sure it gets updated on Trunk.

Hello,

Very interested in using Marshal however I'm not sure how best to handle JSON where the top level structure is an array rather than a dictionary.

We have some JSON that looks like this:

 [
  {
  "id": "111",
  "firstname":"John",
  "surname": "Doe"
  }, {
  "id": "222",
  "firstname":"Jane",
  "surname": "Doe"
}
]

We would like to be able to map this directly into say an array of Users where User conforms to Unmarshaling i.e.

struct User: Unmarshaling {
    var id: Int
    var firstname: String
    var surname: String

    init(object: MarshaledObject) throws {
        id = try object.value(for: "id")
        firstname = try object.value(for: "firstname")
        surname = try object.value(for: "surname")
    }
}

However the library seems to always need a key in order to create the unmarshaled object. The only way I can see to do this now is to have something like:

var jsonObjects: [JSONObject] = try! JSONParser.JSONArrayWithData(data)
    for obj in jsonObjects {
         let user = User()
         user.id = try obj.value("id")
         user.firstname = try obj.value("firstname")
        user.surname = try obj.value("surname")
    }

This does not seem as elegant as being able to create the array of users directly i.e.

let users: [User] = try json.value("users")

What is the best way of handling this kind of JSON format using Marshal?

Thanks

How to get value for key ".tag" from this JSON:

{
    ".tag": "test"
    "name": "something"
}

Marshal splits the key by ., so object.value(for: ".tag") returns nil because tag key is not found.

Sometimes I get into a situation where Date parsing doesn't seem to work.

This:

self.createdAt = try json.value(for: "created_at")

Throws this:

Type mismatch. Expected type Date for key: created_at. Got '__NSCFString'

I can work around this by transforming to a string first, then to Date:

let s: String = try json.value(for: "created_at")
self.createdAt = try Date.value(for: s)

My Date support looks like so:

extension Date {
    @nonobjc static let ISO8601SecondFormatter:DateFormatter = {
        let formatter = DateFormatter()
        formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssZ";
        formatter.timeZone = TimeZone(abbreviation:"GMT")
        return formatter
    }()
    
    static func fromISO8601String(_ dateString:String) -> Date? {
        if let date = ISO8601SecondFormatter.date(from: dateString) {
            return date
        }
        return .none
    }
}

extension Date : ValueType {
    public static func value(_ object: Any) throws -> Date {
        guard let dateString = object as? String else {
            throw MarshalError.typeMismatch(expected: String.self, actual: type(of: object))
        }
        guard let date = Date.fromISO8601String(dateString) else {
            throw MarshalError.typeMismatch(expected: "ISO8601 date string", actual: dateString)
        }
        return date
    }
}

This is needed in order to prevent errors further down the tree from being swallowed into the nil.

Using stringValue for comparison, since KeyType doesn't conform to Equatable.

Hi!

I experienced a small problem when using enums as ValueTypes. I have an enum in a project defined as the following:

enum Week: Int {
    case all = 0, even, odd
}

I implemented the ValueType extension as the following:

extension Week: ValueType {
    public static func value(from object: Any) throws -> Week {
        guard let raw = object as? RawValue else {
            throw MarshalError.typeMismatch(expected: RawValue.self, actual: type(of: object))
        }
        guard let week = Week(rawValue: raw) else {
            throw Error.outOfBounds(raw)
        }
        return week
    }
}

When using this in a type that has a Week property, I get the compiler error 'ambiguous use of X' where X is either <| or value(for:).

I fixed it by using this code in my type that is using Week, but the solution is not that satisfiying. Do you have any other ideas?

let rawWeek: Int = try object <| "week"
guard let week = Week(rawValue: rawWeek) else {
    throw Week.Error.outOfBounds(rawWeek)
}
self.week = week

Thanks in advance!

Hey @jarsen -- this PR may fix #54. It also fixes a scary bug where I thought the function had a local variable any, but it resolved as the function as type Any, which then fails to cast into anything useful. Oops.

I added some tests so this shouldn't regress.

I love Marshal and I'm a bit worried that maybe it's been abandoned, but hopefully you can help me with this:

I've lately started running into this error: Expected type MarshaledObject for key: node. Got 'Optional<Any>'. I can cast the object to [String:Any], but not to [MarshaledObject].

The failure is happening in Unmarshaling.swift:

extension Unmarshaling {
    
    public static func value(from object: Any) throws -> ConvertibleType {
        guard let convertedObject = object as? MarshaledObject else {
            throw MarshalError.typeMismatch(expected: MarshaledObject.self, actual: type(of: object))
        }
        guard let value = try self.init(object: convertedObject) as? ConvertibleType else {
            throw MarshalError.typeMismatch(expected: ConvertibleType.self, actual: type(of: object))
        }
        return value
    }
    
}

If I print the type of the object in the debugger, it's:

(lldb) po type(of: any)
Swift.Optional<Any>

In the debugger it looks like this:

Swift 5 in Xcode 13b, but also happens in 12.5.1

Thanks!

Seems like the only examples I can find on Marshal are converting JSON into an object and not the other way. I'm assuming it's easy but perhaps I'm missing something.

Can you post a test or example of how to go from a marshaled object to a string of json?

So, it's clear to me how to unmarshal a Date, by extending it with the ValueType protocol. But it's not at all clear how to marshal it. I tried various forms of this:

extension
Date : ValueType, Marshaling
{
	public
	static
	func
	value(from inObj: Any)
		throws
		-> Date
	{
		guard
			let timeInterval = inObj as? Double
		else
		{
			throw MarshalError.typeMismatch(expected: Double.self, actual: type(of: inObj))
		}
		
		let date = Date(timeIntervalSinceReferenceDate: timeInterval)
		return date
	}
	
	public
	func
	marshaled()
		-> Double
	{
		return self.timeIntervalSinceReferenceDate
	}
}

But Xcode doesn't like it. In this case, it says Type 'Date' does not conform to protocol 'Marshaling'. Not sure what I'm doing wrong.

Hi,

I was wondering whether it would be possible to simplify Marshal implementation using new Swift features like conditional protocol conformance. This would also simplify creating 3rd party extensions above Marshal.

This would e.g. allow [ValueType] to conform ValueType so lot of code could be then reused/deleted.

I'm open to implementing it but don't wanna waste time on something that wouldn't have a chance to be merged.

Thanks

This construction

extension NSDictionary: MarshaledObject {
    public func any(for key: KeyType) throws -> Any {
        guard let value: Any = self.value(forKeyPath: key.stringValue) else {
            throw MarshalError.keyNotFound(key: key)
        }

is not really safe to use in case when we try to access a field that is not an object. Say, we have this json:

{
	"contact_id": "123456",
	"type": 0,
	"avatar": "",
	"org": {"name": "name"},
}

And this model:

struct Test: Unmarshaling {
    let identifier: String
    let orgName: String?
    init(object: MarshaledObject) throws {
        self.identifier = try object.value(for: "contact_id")
        self.name = try object.value(for: "org.org_name")
    }
}

Sometimes, by accident, server may return this json:

{
	"contact_id": "123456",
	"type": 0,
	"avatar": "",
	"org": "",
}

In that case I get SIGABRT:

Right now I have to workaround it by implementing a private struct for org field and map to it first, but it would be better if the code above would just return nil without crashing