//

// JSONEncodable.swift

// JSONCodable

//

// Created by Matthew Cheok on 17/7/15.

// Copyright © 2015 matthewcheok. All rights reserved.

//

// Encoding Errors

public enum JSONEncodableError: ErrorProtocol, CustomStringConvertible {

case incompatibleTypeError(

elementType: Any.Type

)

case arrayIncompatibleTypeError(

elementType: Any.Type

)

case dictionaryIncompatibleTypeError(

elementType: Any.Type

)

case childIncompatibleTypeError(

key: String,

elementType: Any.Type

)

case transformerFailedError(

key: String

)

public var description: String {

switch self {

case let .incompatibleTypeError(elementType: elementType):

return "JSONEncodableError: Incompatible type \(elementType)"

case let .arrayIncompatibleTypeError(elementType: elementType):

return "JSONEncodableError: Got an array of incompatible type \(elementType)"

case let .dictionaryIncompatibleTypeError(elementType: elementType):

return "JSONEncodableError: Got an dictionary of incompatible type \(elementType)"

case let .childIncompatibleTypeError(key: key, elementType: elementType):

return "JSONEncodableError: Got incompatible type \(elementType) for key \(key)"

case let .transformerFailedError(key: key):

return "JSONEncodableError: Transformer failed for key \(key)"

}

}

}

// Struct -> Dictionary

public protocol JSONEncodable {

func toJSON() throws -> AnyObject

}

public extension JSONEncodable {

func toJSON() throws -> AnyObject {

let mirror = Mirror(reflecting: self)

guard let style = mirror.displayStyle where style == .`struct` || style == .`class` else {

throw JSONEncodableError.incompatibleTypeError(elementType: self.dynamicType)

}

return try JSONEncoder.create({ (encoder) -> Void in

// loop through all properties (instance variables)

for (labelMaybe, valueMaybe) in mirror.children {

guard let label = labelMaybe else {

continue

}

let value: Any

// unwrap optionals

if let v = valueMaybe as? JSONOptional {

guard let unwrapped = v.wrapped else {

continue

}

value = unwrapped

}

else {

value = valueMaybe

}

switch (value) {

case let value as JSONEncodable:

try encoder.encode(value, key: label)

case let value as JSONArray:

try encoder.encode(value, key: label)

case let value as JSONDictionary:

try encoder.encode(value, key: label)

default:

throw JSONEncodableError.childIncompatibleTypeError(key: label, elementType: value.dynamicType)

}

}

})

}

}

public extension Array {//where Element: JSONEncodable {

private var wrapped: [Any] { return self.map{$0} }

public func toJSON() throws -> AnyObject {

var results: [AnyObject] = []

for item in self.wrapped {

if let item = item as? JSONEncodable {

results.append(try item.toJSON())

}

else {

throw JSONEncodableError.arrayIncompatibleTypeError(elementType: item.dynamicType)

}

}

return results

}

}

// Dictionary convenience methods

public extension Dictionary {//where Key: String, Value: JSONEncodable {

public func toJSON() throws -> AnyObject {

var result: [String: AnyObject] = [:]

for (k, item) in self {

if let item = item as? JSONEncodable {

result[String(k)] = try item.toJSON()

}

else {

throw JSONEncodableError.dictionaryIncompatibleTypeError(elementType: item.dynamicType)

}

}

return result

}

}

// JSONEncoder - provides utility methods for encoding

public class JSONEncoder {

var object = JSONObject()

public static func create(_ setup: @noescape (encoder: JSONEncoder) throws -> Void) rethrows -> JSONObject {

let encoder = JSONEncoder()

try setup(encoder: encoder)

return encoder.object

}

private func update(object: JSONObject, keys: [String], value: AnyObject) -> JSONObject

{

var newObject = object

var newKeys = keys

let firstKey = newKeys.removeFirst()

if newKeys.count > 0 {

let innerObject = object[firstKey] as? JSONObject ?? JSONObject()

newObject[firstKey] = update(object: innerObject, keys: newKeys, value: value)

} else {

newObject[firstKey] = value

}

return newObject

}

/*

Note:

There is some duplication because methods with generic constraints need to

take a concrete type conforming to the constraint are unable to take a parameter

typed to the protocol. Hence we need non-generic versions so we can cast from

Any to JSONEncodable in the default implementation for toJSON().

*/

// JSONEncodable

public func encode<Encodable: JSONEncodable>(_ value: Encodable, key: String) throws {

let result = try value.toJSON()

object = update(object: object, keys: key.components(separatedBy: "."), value: result)

}

private func encode(_ value: JSONEncodable, key: String) throws {

let result = try value.toJSON()

object = update(object: object, keys: key.components(separatedBy: "."), value: result)

}

// JSONEncodable?

public func encode<Encodable: JSONEncodable>(_ value: Encodable?, key: String) throws {

guard let actual = value else {

return

}

let result = try actual.toJSON()

object = update(object: object, keys: key.components(separatedBy: "."), value: result)

}

// Enum

public func encode<Enum: RawRepresentable>(_ value: Enum, key: String) throws {

guard let compatible = value.rawValue as? JSONCompatible else {

return

}

let result = try compatible.toJSON()

object = update(object: object, keys: key.components(separatedBy: "."), value: result)

}

// Enum?

public func encode<Enum: RawRepresentable>(_ value: Enum?, key: String) throws {

guard let actual = value else {

return

}

guard let compatible = actual.rawValue as? JSONCompatible else {

return

}

let result = try compatible.toJSON()

object = update(object: object, keys: key.components(separatedBy: "."), value: result)

}

// [JSONEncodable]

public func encode<Encodable: JSONEncodable>(_ array: [Encodable], key: String) throws {

guard array.count > 0 else {

return

}

let result = try array.toJSON()

object = update(object: object, keys: key.components(separatedBy: "."), value: result)

}

public func encode(_ array: [JSONEncodable], key: String) throws {

guard array.count > 0 else {

return

}

let result = try array.toJSON()

object = update(object: object, keys: key.components(separatedBy: "."), value: result)

}

private func encode(_ array: JSONArray, key: String) throws {

guard array.count > 0 && array.elementsAreJSONEncodable() else {

return

}

let encodable = array.elementsMadeJSONEncodable()

let result = try encodable.toJSON()

object = update(object: object, keys: key.components(separatedBy: "."), value: result)

}

// [JSONEncodable]?

public func encode<Encodable: JSONEncodable>(_ value: [Encodable]?, key: String) throws {

guard let actual = value else {

return

}

guard actual.count > 0 else {

return

}

let result = try actual.toJSON()

object = update(object: object, keys: key.components(separatedBy: "."), value: result)

}

// [Enum]

public func encode<Enum: RawRepresentable>(_ value: [Enum], key: String) throws {

guard value.count > 0 else {

return

}

let result = try value.flatMap {

try ($0.rawValue as? JSONCompatible)?.toJSON()

}

object = update(object: object, keys: key.components(separatedBy: "."), value: result)

}

// [Enum]?

public func encode<Enum: RawRepresentable>(_ value: [Enum]?, key: String) throws {

guard let actual = value else {

return

}

guard actual.count > 0 else {

return

}

let result = try actual.flatMap {

try ($0.rawValue as? JSONCompatible)?.toJSON()

}

object = update(object: object, keys: key.components(separatedBy: "."), value: result)

}

// [String:JSONEncodable]

public func encode<Encodable: JSONEncodable>(_ dictionary: [String:Encodable], key: String) throws {

guard dictionary.count > 0 else {

return

}

let result = try dictionary.toJSON()

object = update(object: object, keys: key.components(separatedBy: "."), value: result)

}

public func encode(_ dictionary: [String:JSONEncodable], key: String) throws {

guard dictionary.count > 0 else {

return

}

let result = try dictionary.toJSON()

object[key] = result

}

private func encode(_ dictionary: JSONDictionary, key: String) throws {

guard dictionary.count > 0 && dictionary.valuesAreJSONEncodable() else {

return

}

let encodable = dictionary.valuesMadeJSONEncodable()

let result = try encodable.toJSON()

object = update(object: object, keys: key.components(separatedBy: "."), value: result)

}

// [String:JSONEncodable]?

public func encode<Encodable: JSONEncodable>(_ value: [String:Encodable]?, key: String) throws {

guard let actual = value else {

return

}

guard actual.count > 0 else {

return

}

let result = try actual.toJSON()

object = update(object: object, keys: key.components(separatedBy: "."), value: result)

}

// JSONTransformable

public func encode<EncodedType, DecodedType>(_ value: DecodedType, key: String, transformer: JSONTransformer<EncodedType, DecodedType>) throws {

guard let result = transformer.encoding(value) else {

throw JSONEncodableError.transformerFailedError(key: key)

}

object = update(object: object, keys: key.components(separatedBy: "."), value: result as! AnyObject)

}

// JSONTransformable?

public func encode<EncodedType, DecodedType>(_ value: DecodedType?, key: String, transformer: JSONTransformer<EncodedType, DecodedType>) throws {

guard let actual = value else {

return

}

guard let result = transformer.encoding(actual) else {

return

}

object = update(object: object, keys: key.components(separatedBy: "."), value: result as! AnyObject)

}

}