A super fast & convenient object mapper tailored for your needs

This PR tries to address the issue where you want to map properties to an immutable model.

SafeMappable protocol

public protocol SafeMappable {
  init(_ map: JSONDictionary) throws
}

The new SafeMappable protocol can be used for mapping immutable models.

Usage

struct TestImmutable: SafeMappable {
  var firstName: String
  var lastName: String

  init(_ map: JSONDictionary) throws {
    firstName = try <-map.property("firstName")
    lastName = try <-map.property("lastName")
  }
}

This PR also has some breaking changes; object and objects have been replaced by property and properties. This change was made because I felt that it was more semantically correct.

tl;dr

• [x] Rename object() to property()
• [x] Rename objects() to properties()
• [x] Split source in to separate files
• [x] Introduce prefix operator <-
• [x] Add SafeMappable protocol
• [x] Add propertyOrThrow in Dictionary extension
• [x] Refactor code style
• [x] Remove inspectable

Tries to fix https://github.com/zenangst/Tailor/issues/23

So that we can use it like

self.secret <- map.path(["chaos", 1, "way", "light", 1])?.property("secret")

Initially, I want to use variadic parameter instead of array, but it seems to not work with these LiteralConvertible https://github.com/onmyway133/issues/issues/133

This PR aims to improve the usability of resolving key paths.

With this pull request you can resolve nested paths like this;

XCTAssertEqual(json.path("school.clubs.0.detail.name"), "DC")
    XCTAssertEqual(json.path("school.clubs.0.detail.people.0.first_name"), "Clark")
    XCTAssertEqual(json.path("school.clubs.0.detail.people.0.age"), 78)
    XCTAssertEqual(json.path("school.clubs.0.detail.people")!, [
      [
        "first_name": "Clark",
        "last_name": "Kent",
        "age" : 78
      ],
      [
        "first_name": "Bruce",
        "last_name": "Wayne",
        "age" : 77
      ]
      ])

It can achieve this with the refactoring done in PathAccessible to introduce method overloading for the path method.

For now, we use <- which requires that the variable to be declared as var and has initial values, like

struct Person: Mappable {
      var name: String = ""

      init(_ map: JSONDictionary) {
        self.name <- map.path(["info"])?.property("name")
      }
}

How about having something like parse with DefaultType protocol, so that correct or default value is returned. parse will unwrap optional or return default value. It can be written as postfix operator

struct Person: Mappable {
      let name: String // 😬

      init(_ map: JSONDictionary) {
        self.name = parse(map.path(["info"])?.property("name"))
      }
}

This adds methods for mapping double, float, int and string. When mapping a type, if it cannot be resolved directly, it will now try to resolve it as the closest type available.

If you map a Float but get a Double, Tailor will try to make a Float out of the Double before returning.

Let's say I have an immutable model (which I do have often, and it's a good think to do :smiley: )

struct Person {

  let firstName: String
  let lastName: String
}

let p = Person(firstName: "Sarah ", lastName: "Connor")

Now I want to use Tailor Mapper to map my JSON to the Person type

extension Person: Mappable {
  init(_ map: JSONDictionary) {
    firstName <- map.property("first_name")
    lastName  <- map.property("last_name")
  }
}

let dictionary = ["first_name" : "Sarah", "last_name" : "Connor"]
let model = Person(dictionary)

In that way you can first start with making models and using them directly. After that you can add Mapping support without breaking ability to directly instantiate your Person model

• Remove all the orThrow method. This adds unwrapOrThrow on optional. So this is more like Optional -> Throw. We now don't need to have 2 methods
• Remove some custom operators. We don't really need these
• Also, re-indent all the test files to use 2 spaces

This PR aims to bring a unified and clear public API, now you can resolve keys and key paths using resolve(keyPath:).

Instead of

json.path("school.clubs.1.detail")?.property("name")

You can now write;

json.resolve(keyPath: "school.clubs.1.detail.name")

path has been marked as deprecated.

class DynamicModelSubTitle: Mappable, CustomStringConvertible {

    var title: String? = ""
    var subTitle: String? = ""
    var tag: String? = ""
    var action: String? = ""
    var showAccessory = false

    required convenience init(_ map: [String : AnyObject]) {
        self.init()
        title <- map.property("title")
        subTitle <- map.property("sub_title")
        tag <- map.property("tag")
        action <- map.property("action")


    }
}

with JSON

            {
                "kind":"subTitle",
                "title":"Bank Of America",
                "sub_title":"ACCOUNT # XXXX-1234",
                "tag": "my tag",
                "accessory": true,
                "action":"open:AddBank"
            },

How do I map accessory to the showAccessory property?

There are cases that users just want struct with let declaration. Previously, we have to declare var for <- to work. This just uses simple assignment with default value

• Add DefaultType for type that has default value
• Add <? operator to fall back to default value

struct Book: Mappable {
  let name: String
  let pageCount: Int
  let website: NSURL?

  init(_ map: JSONDictionary) {
    name = <?map.property("name")
    pageCount = <?map.property("page_count")
    website = map.transform("website_url", transformer: NSURL.init(string: ))
  }
}

There are cases like GitHub API https://github.com/onmyway133/Github.swift/tree/master/Sources/Classes/Event where we want to parse and return corresponding subclasses instead, so this PR supports that 😬

Does this library allow to maintain the order of the attributes when deserializing an object to a JSON string? This feature is important for me, since I need to create and compare hashes of JSON strings.

Thanks

Hi, I would like to know if you have any performance benchmarks in comparisons to other popular libraries for reference, since your tag-line stated 'A super fast & convenient object mapper'?