molt 0.1.2

data/bundled/swift_helpers/Identifiable.swift

@@ -0,0 +1,29 @@
+//
+//  Identifiable.swift
+//  YATodo
+//
+//  Created by Marco Cabazal on 2/3/18.
+//  Copyright © 2018 The Chill Mill, Inc. All rights reserved.
+//
+
+import UIKit
+import CoreData
+
+// swiftlint:disable identifier_name
+protocol Identifiable {
+  static var id: String { get }
+}
+
+extension Identifiable {
+
+  // return an introspective string representation of the invoking class, which is
+  // generally a shorter alternative to using R.swift's R.nib.viewClass.identifier
+  static var id: String {
+    return String(describing: self)
+  }
+}
+// swiftlint:enable identifier_name
+
+extension UIViewController: Identifiable { }
+extension UIView: Identifiable { }
+extension NSManagedObject: Identifiable { }

data/bundled/swift_helpers/Loadable.swift

@@ -0,0 +1,37 @@
+//
+//  Loadable.swift
+//  YATodo
+//
+//  Created by Marco Cabazal on 2/3/18.
+//  Copyright © 2018 The Chill Mill, Inc. All rights reserved.
+//
+
+import UIKit
+import PKHUD
+
+protocol Loadable: class {
+  func show(error: Error)
+  func showLoadingIndicator()
+  func hideLoadingIndicator()
+}
+
+extension UIViewController: Loadable {
+
+  func show(error: Error) {
+    switch error {
+    case let error as DisplayableError:
+      HUD.flash(.labeledError(title: error.title, subtitle: error.message), delay: 5.0)
+    default:
+      // TODO: error is not displayable so log specifics of error instead
+      HUD.flash(.labeledError(title: "Ooops", subtitle: "Something is not cooperating"), delay: 5.0)
+    }
+  }
+
+  func showLoadingIndicator() {
+    HUD.show(.progress)
+  }
+
+  func hideLoadingIndicator() {
+    HUD.hide()
+  }
+}

data/bundled/swift_helpers/Networking/APIRouter.swift

@@ -0,0 +1,54 @@
+//
+//  Endpoints.swift
+//  CapoRegime
+//
+//  Created by Marco Cabazal on 18 Jan 2017.
+//  Copyright © 2017 The Chill Mill, Inc. All rights reserved.
+//
+
+import Alamofire
+
+struct Config {
+  static let API = "http://caporegime.rb/v1"
+}
+
+enum APIRouter: URLRequestConvertible {
+  case friends
+
+  private var path: String {
+    switch self {
+    case .friends:
+      return "/friends"
+    }
+  }
+
+  private var method: HTTPMethod {
+    switch self {
+    case .friends:
+      return .get
+    }
+  }
+
+  private var parameters: Parameters? {
+    return nil
+  }
+
+  private var headers: [String: String] {
+    return [ "Content-Type": "application/json" ]
+  }
+
+  func asURLRequest() throws -> URLRequest {
+    let baseURL = try Config.API.asURL()
+    var urlRequest = URLRequest(url: baseURL.appendingPathComponent(path))
+
+    urlRequest.httpMethod = method.rawValue
+
+    for (header, value) in headers {
+      urlRequest.setValue(value, forHTTPHeaderField: header)
+    }
+
+    urlRequest = try JSONEncoding.default.encode(urlRequest, with: parameters)
+
+    return urlRequest
+  }
+}

data/bundled/swift_helpers/StoryboardExtensions.swift

@@ -0,0 +1,49 @@
+//
+//  StoryboardExtensions.swift
+//  YATodo
+//
+//  Created by Marco Cabazal on 18 Jan 2017.
+//  Copyright © 2018 The Chill Mill, Inc. All rights reserved.
+//
+
+import UIKit
+
+enum Storyboard: String {
+  case main = "Main"
+
+  var storyboard: UIStoryboard {
+    return UIStoryboard(name: self.rawValue, bundle: Bundle.main)
+  }
+
+  fileprivate func viewController<T: UIViewController>(as: T.Type, identifier: String,
+                                           function: String = #function, line: Int = #line, file: String = #file) -> T {
+
+    guard let scene = storyboard.instantiateViewController(withIdentifier: identifier) as? T else {
+      fatalError("ViewController with identifier \(identifier), not found. Reference: \(self.rawValue) Storyboard.\nFile : \(file) \nLine Number : \(line) \nFunction : \(function)")
+    }
+
+    return scene
+  }
+
+  func initialViewController() -> UIViewController? {
+    return storyboard.instantiateInitialViewController()
+  }
+}
+
+extension UIViewController {
+
+  static func instantiate(from storyboard: Storyboard) -> Self {
+    return storyboard.viewController(as: self, identifier: self.id)
+  }
+
+  static func instantiate(from storyboard: Storyboard, identifier: String) -> Self {
+    return storyboard.viewController(as: self, identifier: identifier)
+  }
+}
+
+extension UITableViewCell {
+
+  static var nib: UINib {
+    return UINib(nibName: self.id, bundle: Bundle.main)
+  }
+}

data/bundled/template_sets/viper_detail/Presenter.swift.liquid

@@ -0,0 +1,17 @@
+//
+//  {{ module_name }}Interactor.swift
+{% include 'header' %}
+final class {{ module_name }}Presenter {
+
+  weak var view: {{ module_name }}ViewProtocol?
+  var wireFrame: {{ module_name }}WireFrameProtocol?
+  var dataSource: {{ model }}?
+}
+
+// MARK: CALLED BY VIEW
+extension {{ module_name }}Presenter: {{ module_name }}PresenterProtocol {
+
+  func viewDidLoad() {
+    view?.render(content: dataSource)
+  }
+}

data/bundled/template_sets/viper_detail/Protocols.swift.liquid

@@ -0,0 +1,23 @@
+//
+//  {{ module_name }}Protocols.swift
+{% include 'header' %}
+import UIKit
+
+// MARK: Called by VIEW -> Implemented BY PRESENTER
+protocol {{ module_name }}PresenterProtocol: class {
+  weak var view: {{ module_name }}ViewProtocol? { get set }
+  weak var wireFrame: {{ module_name }}WireFrameProtocol? { get set }
+  var dataSource: {{ model }}? { get set }
+
+  func viewDidLoad()
+}
+
+// MARK: PRESENTER -> VIEW
+protocol {{ module_name }}ViewProtocol: Loadable {
+  func render(content: {{ model }}?)
+}
+
+// MARK: PRESENTER -> WIREFRAME
+protocol {{ module_name }}WireFrameProtocol: class {
+  static func prepareModule(with object: {{ model }}) -> UIViewController
+}

data/bundled/template_sets/viper_detail/View.swift.liquid

@@ -0,0 +1,25 @@
+//
+//  {{ module_name }}View.swift
+{% include 'header' %}
+import UIKit
+
+class {{ module_name }}View: UIViewController {
+
+  var presenter: {{ module_name }}PresenterProtocol?
+
+  @IBOutlet weak var titleLabel: UILabel!
+
+  override func viewDidLoad() {
+    super.viewDidLoad()
+    presenter?.viewDidLoad()
+  }
+}
+
+// MARK: CALLED BY PRESENTER
+extension {{ module_name }}View: {{ module_name }}ViewProtocol {
+
+  func render(content: {{ model }}?) {
+    guard let content = content else { return }
+    titleLabel?.text = content.title
+  }
+}

data/bundled/template_sets/viper_detail/WireFrame.swift.liquid

@@ -0,0 +1,21 @@
+//
+//  {{ module_name }}WireFrame.swift
+{% include 'header' %}
+import UIKit
+
+final class {{ module_name }}WireFrame: {{ module_name }}WireFrameProtocol {
+
+  static func prepareModule(with object: {{ model }}) -> UIViewController {
+    let view = {{ module_name }}View.instantiate(from: .main)
+
+    let presenter: {{ module_name }}PresenterProtocol = {{ module_name }}Presenter()
+    let wireFrame = {{ module_name }}WireFrame()
+
+    view.presenter = presenter
+    presenter.view = view
+    presenter.dataSource = object
+    presenter.wireFrame = wireFrame
+
+    return view
+  }
+}

data/bundled/template_sets/viper_table/DataManagers/LocalDataManager.swift.liquid

@@ -0,0 +1,45 @@
+//
+//  {{ module_name }}LocalDataManager.swift
+{% include 'header' %}
+import CoreData
+import Hydra
+
+// MARK: CALLED BY INTERACTOR
+class {{ module_name }}LocalDataManager: {{ module_name }}LocalDataManagerProtocol {
+
+  func retrieveDataFromStorage() -> Promise<[{{ entity }}]>  {
+    return Promise<[{{ entity }}]>(in: .main) { resolve, reject, _ in
+      guard let moc = CoreDataStore.moc else {
+        reject(PersistenceError.mocNotFound)
+        return
+      }
+      do {
+        let request: NSFetchRequest<{{ entity }}> = NSFetchRequest(entityName: {{ entity }}.id)
+        resolve(try moc.fetch(request))
+      } catch {
+        reject(PersistenceError.objectNotFound)
+      }
+    }
+  }
+
+  func saveEntity(id: Int, title: String) -> Promise<Void> {
+    return Promise<Void>(in: .main) { resolve, reject, _ in
+      guard let moc = CoreDataStore.moc else {
+        reject(PersistenceError.mocNotFound)
+        return
+      }
+
+      do {
+        if let entity = NSEntityDescription.entity(forEntityName: {{ entity }}.id, in: moc) {
+          let object = {{ entity }}(entity: entity, insertInto: moc)
+          object.id = Int32(id)
+          object.title = title
+          try moc.save()
+          resolve(())
+        }
+      } catch {
+        reject(PersistenceError.couldNotSaveObject)
+      }
+    }
+  }
+}

data/bundled/template_sets/viper_table/DataManagers/RemoteDataManager.swift.liquid

@@ -0,0 +1,26 @@
+//
+//  {{ module_name }}RemoteDataManager.swift
+{% include 'header' %}
+import Alamofire
+import AlamofireObjectMapper
+import Hydra
+
+// MARK: CALLED BY INTERACTOR
+class {{ module_name }}RemoteDataManager: {{ module_name }}RemoteDataManagerProtocol {
+
+  func retrieveDataFromAPI() -> Promise<[{{ model }}]> {
+    return Promise<[{{ model }}]>(in: .background) { resolve, reject, _ in
+      Alamofire.request(APIRouter.{{ model | downcase }})
+        .validate()
+        .responseArray(keyPath: "{{ model | downcase }}") { (response: DataResponse<[{{ model }}]>) in
+
+          switch response.result {
+          case .success(let data):
+            resolve(data)
+          case .failure:
+            reject(APIError.unknown)
+          }
+      }
+    }
+  }
+}

data/bundled/template_sets/viper_table/Interactor.swift.liquid

@@ -0,0 +1,48 @@
+//
+//  {{ module_name }}Interactor.swift
+{% include 'header' %}
+final class {{ module_name }}Interactor {
+  weak var presenter: {{ module_name }}InteractorOutputProtocol?
+  var localDataManager: {{ module_name }}LocalDataManagerProtocol?
+  var remoteDataManager: {{ module_name }}RemoteDataManagerProtocol?
+}
+
+// MARK: CALLED BY PRESENTER
+extension {{ module_name }}Interactor: {{ module_name }}InteractorProtocol {
+
+  func retrieveData() {
+    localDataManager?.retrieveDataFromStorage().then({ [weak self] persistedData in
+      let data: [{{ model }}] = persistedData.map {
+        return {{ model }}(id: Int($0.id), title: $0.title ?? "", dueDate: $0.dueDate)
+      }
+
+      if !data.isEmpty {
+        self?.presenter?.present(data: data)
+      } else {
+        self?.retrieveDataFromAPI()
+      }
+    }).catch({ [weak self] error in
+      self?.presenter?.present(error: error)
+    })
+  }
+}
+
+extension {{ module_name }}Interactor {
+
+  fileprivate func retrieveDataFromAPI() {
+    remoteDataManager?.retrieveDataFromAPI().then({ [weak self] data in
+      self?.persist(data: data)
+      self?.presenter?.present(data: data)
+    }).catch({ [weak self] error in
+      self?.presenter?.present(error: error)
+    })
+  }
+
+  fileprivate func persist(data: [{{ model }}]) {
+    for item in data {
+      localDataManager?.saveEntity(id: item.id, title: item.title).catch({ [weak self] error in
+        self?.presenter?.present(error: error)
+      })
+    }
+  }
+}

data/bundled/template_sets/viper_table/Presenter.swift.liquid

@@ -0,0 +1,49 @@
+//
+//  {{ module_name }}Presenter.swift
+{% include 'header' %}
+final class {{ module_name }}Presenter {
+
+  weak var view: {{ module_name }}ViewProtocol?
+  var wireFrame: {{ module_name }}WireFrameProtocol?
+  var interactor: {{ module_name }}InteractorProtocol?
+  var dataSource: [{{ model }}] = []
+}
+
+// MARK: CALLED BY VIEW
+extension {{ module_name }}Presenter: {{ module_name }}PresenterProtocol {
+
+  func viewDidLoad() {
+    view?.showLoadingIndicator()
+    interactor?.retrieveData()
+  }
+
+  var numberOfSection: Int { return self.dataSource.count + 1  }
+
+  func numberOfRows(in section: Int) -> Int {
+    return dataSource.count
+  }
+
+  func content(at row: Int) -> {{ model }}? {
+    return dataSource[row]
+  }
+
+  func process(object: {{ model }}) {
+    guard let view = view else { return }
+    wireFrame?.navigate(to: object, from: view)
+  }
+}
+
+// MARK: CALLED BY INTERACTOR
+extension {{ module_name }}Presenter: {{ module_name }}InteractorOutputProtocol {
+
+  func present(data: [{{ model }}]) {
+    self.dataSource = data
+    view?.hideLoadingIndicator()
+    view?.render()
+  }
+
+  func present(error: Error) {
+    view?.hideLoadingIndicator()
+    view?.show(error: error)
+  }
+}

data/bundled/template_sets/viper_table/Protocols.swift.liquid

@@ -0,0 +1,58 @@
+//
+//  {{ module_name }}Protocols.swift
+{% include 'header' %}
+import UIKit
+import Hydra
+
+// MARK: Called by VIEW -> Implemented BY PRESENTER
+protocol {{ module_name }}PresenterProtocol: class {
+  var view: {{ module_name }}ViewProtocol? { get set }
+  var wireFrame: {{ module_name }}WireFrameProtocol? { get set }
+  var interactor: {{ module_name }}InteractorProtocol? { get set }
+
+  func viewDidLoad()
+
+  // datasource
+  var numberOfSection: Int { get }
+  func numberOfRows(in section: Int) -> Int
+  func content(at row: Int) -> <{{ model }}>?
+
+  func process(object: {{ model }})
+}
+
+// MARK: PRESENTER -> INTERACTOR
+protocol {{ module_name }}InteractorProtocol: class {
+  var presenter: {{ module_name }}InteractorOutputProtocol? { get set }
+  var localDataManager: {{ module_name }}LocalDataManagerProtocol? { get set }
+  var remoteDataManager: {{ module_name }}RemoteDataManagerProtocol? { get set }
+
+  func retrieveData()
+}
+
+// MARK: INTERACTOR -> REMOTEDATAMANAGER
+protocol {{ module_name }}RemoteDataManagerProtocol: class {
+  func retrieveDataFromAPI() -> Promise<[{{ model }}]>
+}
+
+// MARK: INTERACTOR -> LOCALDATAMANAGER
+protocol {{ module_name }}LocalDataManagerProtocol: class {
+  func retrieveDataFromStorage() -> Promise<[{{ entity }}]>
+  func saveEntity(id: Int, title: String) -> Promise<Void>
+}
+
+// MARK: INTERACTOR -> PRESENTER
+protocol {{ module_name }}InteractorOutputProtocol: class {
+  func present(data: [{{ model }}])
+  func present(error: Error)
+}
+
+// MARK: PRESENTER -> VIEW
+protocol {{ module_name }}ViewProtocol: Loadable {
+  func render()
+}
+
+// MARK: PRESENTER -> WIREFRAME
+protocol {{ module_name }}WireFrameProtocol: class {
+  static func prepareModule() -> UIViewController
+  func navigate(to object: {{ model }}, from view: {{ module_name }}ViewProtocol)
+}

data/bundled/template_sets/viper_table/View.swift.liquid

@@ -0,0 +1,60 @@
+//
+//  {{ module_name }}View.swift
+{% include 'header' %}
+import UIKit
+
+class {{ module_name }}View: UIViewController {
+
+  var presenter: {{ module_name }}PresenterProtocol?
+
+  @IBOutlet weak var tableView: UITableView!
+
+  override func viewDidLoad() {
+    super.viewDidLoad()
+    tableView.tableFooterView = UIView()
+    tableView.register({{ entity}}Cell.nib, forCellReuseIdentifier: {{ entity}}Cell.id)
+    presenter?.viewDidLoad()
+  }
+
+  override func viewWillAppear(_ animated: Bool) {
+    super.viewWillAppear(animated)
+    if let selectedRow = tableView.indexPathForSelectedRow {
+      tableView.deselectRow(at: selectedRow, animated: true)
+    }
+  }
+}
+
+// MARK: CALLED BY PRESENTER
+extension {{ module_name }}View: {{ module_name }}ViewProtocol {
+
+  func render() {
+    tableView.reloadData()
+  }
+}
+
+// MARK: UITABLEVIEW DATASOURCE
+extension {{ module_name }}View: UITableViewDataSource {
+
+  func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
+    return presenter?.numberOfRows(in: section) ?? 0
+  }
+
+  func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
+    guard let content = presenter?.content(at: indexPath.row),
+      let cell = tableView.dequeueReusableCell(withIdentifier: {{ entity}}Cell.id, for: indexPath) as? {{ entity}}Cell else {
+        return tableView.dequeueReusableCell(withIdentifier: {{ entity}}Cell.id, for: indexPath)
+    }
+
+    cell.configure(with: content)
+    return cell
+  }
+}
+
+// MARK: UITABLEVIEW DELEGATE
+extension {{ module_name }}View: UITableViewDelegate {
+
+  func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
+    guard let content = presenter?.content(at: indexPath.row) else { return }
+    presenter?.process(object: content)
+  }
+}

data/bundled/template_sets/viper_table/WireFrame.swift.liquid

@@ -0,0 +1,43 @@
+//
+//  {{ module_name }}WireFrame.swift
+{% include 'header' %}
+import UIKit
+
+final class {{ module_name }}WireFrame {
+
+  static func prepareModule() -> UIViewController {
+    let navController = UINavigationController.instantiate(from: .main, identifier: "mainNavigationController")
+
+    guard let view = navController.childViewControllers.first as? {{ module_name }}View else {
+      return UIViewController()
+    }
+
+    let presenter: {{ module_name }}PresenterProtocol & {{ module_name }}InteractorOutputProtocol = {{ module_name }}Presenter()
+    let interactor: {{ module_name }}InteractorProtocol = {{ module_name }}Interactor()
+    let wireFrame: {{ module_name }}WireFrameProtocol = {{ module_name }}WireFrame()
+    let localDataManager: {{ module_name }}LocalDataManagerProtocol = {{ module_name }}LocalDataManager()
+    let remoteDataManager: {{ module_name }}RemoteDataManagerProtocol = {{ module_name }}RemoteDataManager()
+
+    // INTEGRATION
+    view.presenter = presenter
+    presenter.view = view
+    presenter.wireFrame = wireFrame
+    presenter.interactor = interactor
+    interactor.presenter = presenter
+    interactor.localDataManager = localDataManager
+    interactor.remoteDataManager = remoteDataManager
+
+    return navController
+  }
+}
+
+// MARK: NAVIGATION
+extension {{ module_name }}WireFrame: {{ module_name }}WireFrameProtocol {
+
+  func navigate(to object: {{ model }}, from view: {{ module_name }}ViewProtocol) {
+    guard let sourceView = view as? UIViewController else { return }
+
+    let detailVC = {{ module_name }}DetailWireFrame.prepareModule(with: object)
+    sourceView.navigationController?.pushViewController(detailVC, animated: true)
+  }
+}

data/lib/generamba/string-colorize.rb

@@ -0,0 +1,31 @@
+# Borrowed from Egor Tolstoy, Beniamin Sarkisyan, Andrey Zarembo et al (Generamba/Rambler)
+class String
+
+  def colorize(color_code)
+    "\e[#{color_code}m#{self}\e[0m"
+  end
+
+  def red
+    colorize(31)
+  end
+
+  def green
+    colorize(32)
+  end
+
+  def yellow
+    colorize(33)
+  end
+
+  def blue
+    colorize(34)
+  end
+
+  def pink
+    colorize(35)
+  end
+
+  def light_blue
+    colorize(36)
+  end
+end