Merge pull request #210 from DeclarativeHub/swift-5

ReactiveKit v3.10 (Swift 5)

Author: srdanrasic

.swift-version

@@ -1,19 +1,26 @@
-language: objective-c
-osx_image: xcode9.3
+language: swift
+osx_image: xcode10.2
 
-# Travis is currently experiencing issues with Xcode builds: https://github.com/travis-ci/travis-ci/issues/6675#issuecomment-257964767
-# When this is resolved, remove the entire `before_install` block, as well as the `travis_retry` command below.
-before_install:
-  - export IOS_SIMULATOR_UDID=`instruments -s devices | grep "iPhone 7 (11.3" | awk -F '[ ]' '{print $4}' | awk -F '[\[]' '{print $2}' | sed 's/.$//'`
-  - echo $IOS_SIMULATOR_UDID
-  - open -a "simulator" --args -CurrentDeviceUDID $IOS_SIMULATOR_UDID
+jobs:
+    include:
+        - stage: "Xcode"
+          name: "Run tests on iOS"
+          script: xcrun xcodebuild test -destination "platform=iOS Simulator,OS=12.2,name=iPhone X" -workspace "ReactiveKit.xcworkspace" -scheme "ReactiveKit-iOS"
+          after_success: 'bash <(curl -s https://codecov.io/bash)'
+        -
+          name: "Build for macOS"
+          script: xcrun xcodebuild build -destination "platform=macOS" -workspace "ReactiveKit.xcworkspace" -scheme "ReactiveKit-macOS"
+        -
+          name: "Build for tvOS"
+          script: xcrun xcodebuild build -destination "platform=tvOS Simulator,OS=12.2,name=Apple TV 4K" -workspace "ReactiveKit.xcworkspace" -scheme "ReactiveKit-tvOS"
+        -
+          name: "Build for watchOS"
+          script: xcrun xcodebuild build -destination "platform=watchOS Simulator,OS=5.2,name=Apple Watch Series 4 - 44mm" -workspace "ReactiveKit.xcworkspace" -scheme "ReactiveKit-watchOS"
 
-install:
-  - gem install xcpretty
+        - stage: "Swift Package Manager"
+          name: "Run Tests"
+          script: swift test
 
-script:
-  - set -o pipefail && travis_retry xcodebuild -project ReactiveKit.xcodeproj -scheme ReactiveKit-iOS -sdk iphonesimulator -destination 'platform=iOS Simulator,name=iPhone 7,OS=11.3' test | xcpretty
-  - swift test
-
-after_success:
-  - bash <(curl -s https://codecov.io/bash)
+        - stage: "CocoaPods"
+          name: "Lint Podspec"
+          script: pod lib lint

.travis.yml

@@ -1,13 +1,13 @@
-// swift-tools-version:4.1
+// swift-tools-version:5.0
 import PackageDescription
 
 let package = Package(
-  name: "ReactiveKit",
-  products: [
-    .library(name: "ReactiveKit", targets: ["ReactiveKit"])
-  ],
-  targets: [
-    .target(name: "ReactiveKit", path: "Sources"),
-    .testTarget(name: "ReactiveKitTests", dependencies: ["ReactiveKit"])
-  ]
+    name: "ReactiveKit",
+    products: [
+        .library(name: "ReactiveKit", targets: ["ReactiveKit"])
+    ],
+    targets: [
+        .target(name: "ReactiveKit", path: "Sources"),
+        .testTarget(name: "ReactiveKitTests", dependencies: ["ReactiveKit"])
+    ]
 )

Package.swift

@@ -0,0 +1,56 @@
+//: [Previous](@previous)
+
+import Foundation
+import ReactiveKit
+import PlaygroundSupport
+
+PlaygroundPage.current.needsIndefiniteExecution = true
+
+//: # Creating Signals
+//: Uncomment the `observe { ... }` line to explore the behaviour!
+
+SafeSignal(just: "Jim")
+//.observe { print($0) }
+
+SafeSignal(just: "Jim after 1 second", after: 1)
+//.observe { print($0) }
+
+SafeSignal(sequence: [1, 2, 3])
+//.observe { print($0) }
+
+SafeSignal(sequence: [1, 2, 3], interval: 1)
+//.observe { print($0) }
+
+SafeSignal(sequence: 1..., interval: 1)
+//.observe { print($0) }
+
+SafeSignal(performing: {
+    (0...1000).reduce(0, +)
+})
+//.observe { print($0) }
+
+Signal<String, NSError>(evaluating: {
+    if let file = try? String(contentsOf: URL(fileURLWithPath: "list.txt")) {
+        return .success(file)
+    } else {
+        return .failure(NSError(domain: "No such file", code: 0, userInfo: nil))
+    }
+})
+//.observe { print($0) }
+
+Signal(catching: {
+    try String(contentsOf: URL(string: "https://pokeapi.co/api/v2/pokemon/ditto/")!, encoding: .utf8)
+})
+//.observe { print($0) }
+
+Signal<Int, NSError> { observer in
+    observer.next(1)
+    observer.next(2)
+    observer.completed()
+    return BlockDisposable {
+        print("disposed")
+    }
+}
+//.observe { print($0) }
+
+//: [Next](@next)

Playground.playground/Contents.swift

@@ -0,0 +1,16 @@
+//: Playground - noun: a place where people can play
+
+import ReactiveKit
+import PlaygroundSupport
+
+//: Explore ReactiveKit here
+
+enum MyError: Error {
+    case unknown
+}
+
+let a = Signal<Int, Error>(sequence: 0...4, interval: 0.5)
+let b = SafeSignal(sequence: 0...2, interval: 2)
+
+b.concat(with: b)
+

Playground.playground/Pages/Creating Signals.xcplaygroundpage/Contents.swift

@@ -0,0 +1,91 @@
+//: [Previous](@previous)
+
+import Foundation
+import ReactiveKit
+import PlaygroundSupport
+
+PlaygroundPage.current.needsIndefiniteExecution = true
+
+//: # Observing Signals
+
+// Let's make a signal that simulates doing some work like loading of a large file.
+
+let loadedFile = SafeSignal<String> { observer in
+    print("Now loading file...")
+    sleep(1)
+    observer.completed(with: "first line\nsecond line")
+    print("File loaded.")
+    return NonDisposable.instance
+}
+
+// If you run the playground up to this line, nothing will happen.
+// You console log will be empty. Even if we access the signal
+
+_ = loadedFile
+
+// still nothing happens. We could transform it using any of the operators
+
+let numberOfLines = loadedFile
+    .map { $0.split(separator: "\n").count }
+    .map { "The file has \($0) lines." }
+
+// and if you run the playground up to this line, nothing again.
+
+// While this might be a bit confusing, it's the most powerful feature of signals and
+// functional-reactive programming. Signals allow us to express the logic without doing side effects.
+
+// In our example, we've defined how to load a file and how to count number of lines
+// in the file, but we have not actually loaded the file nor counted the lines.
+
+// To make side effects, to do the work, one has to observe the signal. It's the act
+// of observing that starts everything! Let's try observing the signal.
+
+numberOfLines.observe { event in
+    print(event)
+}
+
+// Run the playground up to this line and watch the console log.
+// It's only now that the file gets loaded, signal transformed and events printed.
+
+// This is very useful in real world development, but be aware of a caveat: observing the
+// signal again will repeat the side efects. In our example, the file will be loaded again.
+
+numberOfLines.observe { event in
+    print(event)
+}
+
+// Bummer? No. Once you get more into functional-reactive parading you will see that
+// being able to express the logic without doing side effects outweights this inconvenience.
+// In order to share the sequence, all we need to do is apply `shareReplay` operator.
+
+let sharedLoadedFile = loadedFile.shareReplay()
+
+// The first time we observe the shared signal, it will load the file:
+
+sharedLoadedFile.observe { print($0) }
+
+// However, any subsequent observation will just use the shared sequence cached in the memory:
+
+sharedLoadedFile.observe { print($0) }
+sharedLoadedFile.observe { print($0) }
+
+// There are few convience methods for observing signals. When you are only interested into elements
+// of the signal, as opposed to events that contain element, you could just observe next events:
+
+sharedLoadedFile.observeNext { fileContent in
+    print(fileContent)
+}
+
+// If you are interested only when the signal completes, then observe just the completed event:
+
+sharedLoadedFile.observeCompleted {
+    print("Done")
+}
+
+// Some signals can fail with an error. When you are interested only in the failure, observe the failed event:
+
+sharedLoadedFile.observeFailed { error in
+    print("Failed with error", error) // Will not happen because our signal doesn't fail.
+}
+
+//: [Next](@next)