This is a super minor PR. It just adds the types to all properties on Item to help the complier along. Even if this is super tiny and shouldn’t really affect anything, I thought it would be a good idea to just do it, one could consider it “best practice” to always declare properties with a type.

I am one of those who think that is a good idea :)

@zenangst Got a new idea regarding our discussions about meta. So instead of using enums or magic generators we can use Mappable structs 😄

struct ProductMeta {
  var id = 0
  var name: String?
}

extension ProductMeta: Mappable {
  init(_ map: JSONDictionary) {
    id <- map.property("id")
    name <- map.property("name")
  }
}

let productMeta = ProductMeta(id: 11, name: "Name")
let viewModel = ViewModel(title: "Title", meta: productMeta)
// ...
let meta: ProductMeta = viewModel.metaInstance()
print(meta.id) // => 11

My only concern is than it might be too much code, because you have to implement mapping, don't see any way to avoid this, even though property key always reflects the property name. But with this approach you write string only once which is nice.

This PR removes Fakery from the tests and as a dependency. I couldn't get it working for the tests on tvOS so I decide on removing it. We can always introduce it later on but right now it is needed for migration of other projects.

Would be nice to implement a script that goes through your models and generates a code for the each property on it:

import Brick

extension ViewModel {

  var metaId: Int? {
    set(value) {
      meta["id"] = value
    }
    get {
      return meta("id", type: Int.self)
    }
  }

  func metaId(value: Int) -> Int {
    return meta("id", value)
  }

  ///...
}

Then instead of "magic strings" you would use:

viewModel.id = 11
viewModel.id(0) // => value to 0 by default
viewModel.id // optional value

This PR improves working with the children property on Item.

It is now included when comparing Item's using ===.

The property is now also available in the initializer.

When working with custom structs, you can implement the new DictionaryConvertable to make it easier to add them as children to an Item.

This PR cleans up the dictionary representation of Item. The thing that it fixes is that it checks if there are any children before adding it to the dictionary. This will help clean up your JSON file as it won’t add empty keys for children.

We have had quiet a few cases where we have to fallback to use meta when showing longer pieces of text when displaying an Item.

By adding text has a property, you get one more field that you can rely on and it fits quiet a lot of cases.

It won’t solve everything that in my opinion I think it’s an okay thing to have on the Item.

This is a breaking change, it renames the ViewModel struct to Item and ViewConfigurable to ItemConfigurable.

It should be very easy to migrate to the new version as you only need to search and replace those changes and should be done in a jiffy.

This PR came to be after a discussion that me and @vadymmarkov had about naming. ViewModel kind of implies that it holds content for the entire screen as it would potentially deal with ViewController.

And the second reason is that it is mainly used in Spots where we always refer to the ViewModel as an Item.

Item is abstract to work on multiple instances, where as ViewModel implies a specific scenario where it will be used. You can always argue that it is in fact styling a specific view as ViewConfigurable is a property on the underlaying component, a cell for example.

Personally I think this is the best name for what it does. I hope you do as well.

This PR removes the children property from the comparison as it doesn’t work like intended because it is an array of AnyObject. If you want to include it you can make an extension in your implementation.

We had a minor bug in the init method that maps size to Item. This was caused by type-casting that worked in earlier versions of Swift but it no longer supported.

What we do to fix this issue is to resolve the value as a Double and the create a CGSize using both width and height from the JSON payload.

Improved the tests to take size into account when testing the Item.

This PR adds a new property to the ViewModel. The new property is called Identifier and is of type Int. This can be used to achieve uniqueness in your view models. It can represent an ID that you get from your backend or it can be a computed String that you assign yourself.

When assigning String, you can do so by passing the hash value for that string.

let item = ViewModel(identifier: "user-34".hashValue)