Latest1.0.0
Homepagehttps://github.com/oreninit/Reuse
LicenseMIT
Platformsios 9.3
FrameworksUIKit
Authors

Version
License
Platform

About Reuse

Reuse was created in an attempt to avoid the tedious, repetitive work required to populate UITableViews/UICollectionViews, in a simple to use, unified way.

It uses the concept of InstanceReusers, a single configurator to manage all similar items.
Once created, all data will be provided from the InstanceReuser to drive the UI. It will also handle interaction and database updates.

Example

Say we need to display a list of people.
Let’s follow the most common pattern.

First, we create some structure to hold our data:

class PeopleDatabase {

    var people: [Person]

    init(people: [Person]) {
        self.people = people
    }
}

Second, we have our view controller:

class PeopleViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {

    private let cellIdentifier: String = "person.cell.id"

    @IBOutlet weak var tableView: UITableView!

    var database: PeopleDatabase!

    func viewDidLoad() {
        super.viewDidLoad()

        tableView.delegate = self
        tableView.dataSource = self
    }

    func numberOfSections(in tableView: UITableView) -> Int {
        return 1
    }

    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return database.people.count
    }

    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let person = database.people[indexPath.row]
        let cell = tableView.dequeueReusableCell(withIdentifier: cellIdentifier, for: indexPath) as! PersonCell
        cell.nameLabel.text = person.name
        cell.emailLabel.text = person.email
        // ...
        return cell
    }

    func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
        return 120.0
    }

    func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
        let person = database.people[indexPath.row]
        let viewController = PersonViewController(person: person)
        navigationController?.push(viewController, animated: true)
        tableView.deselectRow(at: indexPath, animated: true)
    }

    func tableView(_ tableView: UITableView, commit editingStyle: UITableViewCellEditingStyle, forRowAt indexPath: IndexPath) {
        guard editingStyle == .delete else { return }
        // delete entry from database
        // update table
    }

    func tableView(_ tableView: UITableView, canMoveRowAt indexPath: IndexPath) -> Bool {
        return true
    }

    func tableView(_ tableView: UITableView, moveRowAt sourceIndexPath: IndexPath, to destinationIndexPath: IndexPath) {
        // update database
    }

}

It’s okay when you have a single table, but it’s not scalable and will require some code duplications when you have more screens.

Personal note:

For me, I found that I lacked consistency in structuring this approach, sometime in the same project. That means theres a learning process each time I revisited code.

This is what Reuse is for. Having a reusable component system that could be applied to instance and can be shared across the app.

Let’s modify the project to Reuse.

First, we implement the database protocols:

extension PeopleDatabase: Section, DataProvider {

    // MARK: DataProvider protocol

    var objects: [Usable] {
        get { return people }
        set { people = newValue }
    }

    func canDeleteObject(at index: ObjectIndex) -> Bool {
        return true
    }

    func canMoveObject(at index: ObjectIndex) -> Bool {
        return true
    }
}

By making our database both a DataProvider and a Section, we basically say it only has one section.

Then we create a reusable instance to configure our cells.

struct PersonReuser: InstanceReuser {

    var viewIdentifier: String { return "person.cell.id" }
    var height: CGFloat { return 120.0 }

    private var person: Person?
    private weak var navigationController: UINavigationController?

    // We inject a navigation controller to handle our navigation.
    // I would prefer injecting some `Navigator` protocol, which will allow easier testing and abstraction, but for simplicity we'll just use this.
    init(navigationController: UINavigationController?) {
        self.navigationController = navigationController
    }

    // MARK: InstanceReuser protocol

    mutating func setObject(_ object: Usable) {
        person = object as? Person
    }

    func configure(_ reusable: Reusable) -> Bool {
        guard let person = person, let cell = reusable as? PersonCell else { return false }        
        cell.nameLabel?.text = person.name
        cell.emailLabel?.text = person.email
        return true
    }

    func select() {
        guard let person = person else { return }
        let viewController = PersonViewController(person: person)
        navigationController?.push(viewController, animated: true)
    }
}

Now all that’s left is to refactor our view controller to create a Reuser and let it handle everything for us.

class PeopleViewController: UIViewController {

    @IBOutlet weak var tableView: UITableView!

    var database: PeopleDatabase!
    private var reuser: Reuser!

    func viewDidLoad() {
        super.viewDidLoad()
        setupReuser()
        tableView.passHandling(to: reuser)
    }

    private func setupReuser() {
        reuser = Reuser(dataProvider: database)
        let instanceReuser = PersonReuser(navigationController: navigationController)
        reuser.register(instanceReuser, forObject: Person.self)
    }
}

And you’re done. Reuse will handle everything else.
You can add logic to the PersonReuser or you could avoid writing it at all and just use the generic provided one.
If you need more control, you could implement the UITableViewDataSource and UITableViewDelegate functions and just access your reuser using a subscript. For example:

func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
    reuser[indexPath].select()
    tableView.deselectRow(at: indexPath, animated: true)
}

Now, if you need it elsewhere, just Reuse it. No code duplications.
It easy to maintain, update or replace.

There’s more you could do with it, but I’ll let you explore.

Hope it will help you the same as it helps me.

Installation

Reuse is available through CocoaPods. To install
it, simply add the following line to your Podfile:

pod 'Reuse'

Author

Oren Farhan

License

Reuse is available under the MIT license. See the LICENSE file for more info.

Latest podspec

{
    "name": "Reuse",
    "version": "1.0.0",
    "summary": "A library to simplify the process of populating table views and collection views",
    "description": "Reuse is a simple library which helps tackle the tedious task of populating UITableView/UICollectionView simply and elegantly.",
    "homepage": "https://github.com/oreninit/Reuse",
    "license": {
        "type": "MIT",
        "file": "LICENSE"
    },
    "authors": {
        "Oreninit": "[email protected]"
    },
    "source": {
        "git": "https://github.com/oreninit/Reuse.git",
        "tag": "1.0.0"
    },
    "social_media_url": "https://twitter.com/oreninit",
    "platforms": {
        "ios": "9.3"
    },
    "source_files": "Reuse/Classes/**/*",
    "frameworks": "UIKit"
}

Pin It on Pinterest

Share This