Merge pull request #68 from k8mil/master

Support for Moya 9.0.0. Add support for ReactiveSwift and RxSwift

Author: ivanbruel

Moya-ObjectMapper.podspec

@@ -22,7 +22,7 @@ Pod::Spec.new do |s|
 
   s.subspec "Core" do |ss|
     ss.source_files  = "Source/*.swift"
-    ss.dependency "Moya", '~> 8.0'
+    ss.dependency "Moya", '~> 9.0'
     ss.dependency "ObjectMapper", '~> 2.2'
     ss.framework  = "Foundation"
   end
@@ -34,10 +34,10 @@ Pod::Spec.new do |s|
     ss.dependency "RxSwift", '~> 3.1'
   end
 
-  # s.subspec "ReactiveCocoa" do |ss|
-  #   ss.source_files = "Source/ReactiveCocoa/*.swift"
-  #   ss.dependency "Moya/ReactiveCocoa"
-  #   ss.dependency "Moya-ObjectMapper/Core"
-  #   ss.dependency "ReactiveSwift"
-  # end
+  s.subspec "ReactiveSwift" do |ss|
+    ss.source_files = "Source/ReactiveSwift/*.swift"
+    ss.dependency "Moya/ReactiveSwift"
+    ss.dependency "Moya-ObjectMapper/Core"
+    ss.dependency "ReactiveSwift"
+  end
 end

README.md

@@ -15,16 +15,18 @@ Due to the fact that most libraries haven't officially released a Swift 3.0 vers
 
 ```ruby
 pod 'Moya-ObjectMapper'
-pod 'Moya'
 ```
 
 The subspec if you want to use the bindings over RxSwift.
 
 ```ruby
 pod 'Moya-ObjectMapper/RxSwift'
-pod 'Moya'
-pod 'RxSwift'
+```
+
+The subspec if you want to use the bindings over ReactiveSwift.
 
+```ruby
+pod 'Moya-ObjectMapper/ReactiveSwift'
 ```
 
 # Usage
@@ -54,7 +56,7 @@ struct Repository: Mappable {
 }
 ```
 
-## 1. Without RxSwift
+## 1. Without RxSwift and ReactiveSwift
 
 
 ```swift
@@ -90,19 +92,35 @@ GitHubProvider.request(.userRepositories(username), completion: { result in
 
 ```swift
 GitHubProvider.request(.userRepositories(username))
-  .mapArray(Repository)
+  .mapArray(Repository.self)
   .subscribe { event -> Void in
     switch event {
     case .next(let repos):
       self.repos = repos
     case .error(let error):
       print(error)
-    default:
-      break
+    default: break
     }
   }.addDisposableTo(disposeBag)
 ```
 
+
+## 2. With ReactiveSwift
+
+```swift
+GitHubProvider.request(.userRepositories(username))
+  .mapArray(Repository.self)
+  .start { event in
+    switch event {
+    case .value(let repos):
+      self.repos = repos
+    case .failed(let error):
+      print(error)
+    default: break
+    }
+  }
+```
+
 # Contributing
 
 Issues and pull requests are welcome!

Source/ReactiveCocoa/SignalProducer+ObjectMapper.swift

@@ -0,0 +1,34 @@
+import ReactiveSwift
+import Moya
+import ObjectMapper
+
+/// Extension for processing Responses into Mappable objects through ObjectMapper
+extension SignalProducerProtocol where Value == Moya.Response, Error == MoyaError {
+
+    /// Maps data received from the signal into an object which implements the Mappable protocol.
+    /// If the conversion fails, the signal errors.
+    public func mapObject<T:BaseMappable>(_ type: T.Type, context: MapContext? = nil) -> SignalProducer<T, MoyaError> {
+        return producer.flatMap(.latest) {
+            (response: Response) -> SignalProducer<T, Error> in
+            return unwrapThrowable { try response.mapObject(type, context: context) }
+        }
+    }
+
+    /// Maps data received from the signal into an array of objects which implement the Mappable
+    /// protocol.
+    /// If the conversion fails, the signal errors.
+    public func mapArray<T:BaseMappable>(_ type: T.Type, context: MapContext? = nil) -> SignalProducer<[T], MoyaError> {
+        return producer.flatMap(.latest) { (response: Response) -> SignalProducer<[T], Error> in
+            return unwrapThrowable { try response.mapArray(type, context: context) }
+        }
+    }
+}
+
+/// Maps throwable to SignalProducer
+private func unwrapThrowable<T>(_ throwable: () throws -> T) -> SignalProducer<T, MoyaError> {
+    do {
+        return SignalProducer(value: try throwable())
+    } catch {
+        return SignalProducer(error: error as! MoyaError)
+    }
+}

Source/ReactiveSwift/SignalProducer+ObjectMapper.swift

@@ -0,0 +1,66 @@
+//
+//  Single+MoyaObjectMapper.swift
+//
+//  Created by Ivan Bruel on 09/12/15.
+//  Copyright © 2015 Ivan Bruel. All rights reserved.
+//
+
+import Foundation
+import RxSwift
+import Moya
+import ObjectMapper
+
+
+/// Extension for processing Responses into Mappable objects through ObjectMapper
+public extension PrimitiveSequence where TraitType == SingleTrait, ElementType == Response {
+
+    /// Maps data received from the signal into an object
+    /// which implements the Mappable protocol and returns the result back
+    /// If the conversion fails, the signal errors.
+    public func mapObject<T:BaseMappable>(_ type: T.Type, context: MapContext? = nil) -> Single<T> {
+        return observeOn(ConcurrentDispatchQueueScheduler(qos: .background))
+                .flatMap { response -> Single<T> in
+                    return Single.just(try response.mapObject(type, context: context))
+                }
+                .observeOn(MainScheduler.instance)
+    }
+
+    /// Maps data received from the signal into an array of objects
+    /// which implement the Mappable protocol and returns the result back
+    /// If the conversion fails, the signal errors.
+    public func mapArray<T:BaseMappable>(_ type: T.Type, context: MapContext? = nil) -> Single<[T]> {
+        return observeOn(ConcurrentDispatchQueueScheduler(qos: .background))
+                .flatMap { response -> Single<[T]> in
+                    return Single.just(try response.mapArray(type, context: context))
+                }
+                .observeOn(MainScheduler.instance)
+    }
+}
+
+
+// MARK: - ImmutableMappable
+
+public extension PrimitiveSequence where TraitType == SingleTrait, ElementType == Response {
+
+    /// Maps data received from the signal into an object
+    /// which implements the ImmutableMappable protocol and returns the result back
+    /// If the conversion fails, the signal errors.
+    public func mapObject<T:ImmutableMappable>(_ type: T.Type, context: MapContext? = nil) -> Single<T> {
+        return observeOn(ConcurrentDispatchQueueScheduler(qos: .background))
+                .flatMap { response -> Single<T> in
+                    return Single.just(try response.mapObject(type, context: context))
+                }
+                .observeOn(MainScheduler.instance)
+    }
+
+    /// Maps data received from the signal into an array of objects
+    /// which implement the ImmutableMappable protocol and returns the result back
+    /// If the conversion fails, the signal errors.
+    public func mapArray<T:ImmutableMappable>(_ type: T.Type, context: MapContext? = nil) -> Single<[T]> {
+        return observeOn(ConcurrentDispatchQueueScheduler(qos: .background))
+                .flatMap { response -> Single<[T]> in
+                    return Single.just(try response.mapArray(type, context: context))
+                }
+                .observeOn(MainScheduler.instance)
+    }
+}