use with RxRealm about rxdatasources HOT 10 CLOSED

import Foundation
import RealmSwift
import RxSwift
import RxRealm
import RxDataSources
import RxOptional

class Goal: Object {
    dynamic var name = ""
}

struct GoalSection {
    var header: String
    var items: [GoalItem]
}

struct GoalItem {
    let goal: Goal
}

extension GoalSection: AnimatableSectionModelType {
    typealias Item = GoalItem
    var identity: String {
        return header
    }
    init(original: GoalSection, items: [GoalItem]) {
        self = original
        self.items = items
    }
}

extension GoalItem: IdentifiableType {
    typealias Identity = Goal
    var identity: Goal {
        return goal
    }
}

extension GoalItem: Equatable {}
func == (lhs: GoalItem, rhs: GoalItem) -> Bool {
    return lhs.goal == rhs.goal
}

enum GoalListCommand {
    case Set(List<Goal>)
    case Add(Goal)
    case Update(Goal, NSIndexPath)
    case Delete(NSIndexPath)
}

struct GoalSectionModel {
    let sections: [GoalSection]
    func executingCommand(command: GoalListCommand) -> GoalSectionModel {
        switch command {
        case let .Set(goals):
            let items = goals.map(GoalItem.init)
            let section = GoalSection(header: "goalList", items: items)
            return GoalSectionModel(sections: [section])
        case let .Add(goal):
            var sections = self.sections
            var section = sections.first!
            let item = GoalItem(goal: goal)
            section.items.append(item)
            sections[0] = section
            return GoalSectionModel(sections: sections)
        case let .Delete(indexPath):
            var sections = self.sections
            var section = sections.first!
            section.items.removeAtIndex(indexPath.row)
            sections[0] = section
            return GoalSectionModel(sections: sections)
        case let .Update(goal, indexPath):
            var sections = self.sections
            var section = sections.first!
            section.items[indexPath.row] = GoalItem(goal: goal)
            sections[0] = section
            return GoalSectionModel(sections: sections)
        }
    }
}

class GoalVM {

    let tablevm: Observable<[GoalSection]>

    init(goalList: List<Goal>) {
        let initialCommand = Observable.just(GoalListCommand.Set(goalList))

        let changeCommands = goalList
            .asObservableChangeset()
            .flatMap { (_, changeset) -> Observable<Observable<GoalListCommand>> in
                guard let changeset = changeset else { return Observable.empty() }
                let delete = changeset.deleted.first == nil ?
                    Observable.empty() :
                    Observable.just(changeset.deleted.first)
                        .filterNil()
                        .map { GoalListCommand.Delete(NSIndexPath(forRow: $0, inSection: 0)) }
                let insert = changeset.inserted.first == nil ?
                    Observable.empty() :
                    Observable.just(changeset.inserted.first)
                        .filterNil()
                        .map { _ in GoalListCommand.Add(goalList.last!) }
                let update = changeset.updated.first == nil ?
                    Observable.empty() :
                    Observable.just(changeset.updated.first)
                        .filterNil()
                        .map { GoalListCommand.Update(goalList[$0], NSIndexPath(forRow: $0, inSection: 0)) }
                return Observable.of(delete, insert, update)
            }
            .merge()

        let commands = Observable.of(initialCommand, changeCommands)
            .merge()

        tablevm = commands
            .scan(GoalSectionModel(sections: [])) { $0.executingCommand($1) }
            .map { $0.sections }
    }
}

// goalList is List<Goal> datas
let vm = GoalVM(goalList: goalList)
let dataSource = RxTableViewSectionedAnimatedDataSource<GoalSection>()

tableView.registerClass(UITableViewCell.self, forCellReuseIdentifier: "cell")

dataSource.configureCell = { (ds, tv, ip, item) in
            let cell = tv.dequeueReusableCellWithIdentifier("cell", forIndexPath: ip)
            cell.textLabel?.text = item.goal.name
            return cell
        }

vm.tablevm
            .bindTo(tableView.rx_itemsWithDataSource(dreamTableData))
            .addDisposableTo(disposeBag)

let dataSource = RxTableViewSectionedReloadDataSource<SectionModel<String, Lap>>()
let laps = realm.objects(Lap).sorted("time", ascending: false).asObservableArray()
laps.flatMap { Observable.just([SectionModel(model: "test", items: $0)]) }
            .bindTo(tableView.rx_itemsWithDataSource(dataSource))
            .addDisposableTo(bag)