(lhs: E, rhs: E.ValueType) throws where E.ValueType: Comparable {
223 | let value = try lhs.expression()
224 | guard value! <= rhs else {
225 | throw lhs.failure("\(String(describing: value)) is not less than or equal to \(rhs)")
226 | }
227 | }
228 |
--------------------------------------------------------------------------------
/Linker/LinkerTests/Spectre/Failure.swift:
--------------------------------------------------------------------------------
1 | public protocol FailureType : Error {
2 | var function: String { get }
3 | var file: String { get }
4 | var line: Int { get }
5 |
6 | var reason: String { get }
7 | }
8 |
9 | struct Failure : FailureType {
10 | let reason: String
11 |
12 | let function: String
13 | let file: String
14 | let line: Int
15 |
16 | init(reason: String, function: String = #function, file: String = #file, line: Int = #line) {
17 | self.reason = reason
18 | self.function = function
19 | self.file = file
20 | self.line = line
21 | }
22 | }
23 |
24 | struct Skip: Error {
25 | let reason: String?
26 | }
27 |
28 | public func skip(_ reason: String? = nil) -> Error {
29 | return Skip(reason: reason)
30 | }
31 |
32 |
33 | public func failure(_ reason: String? = nil, function: String = #function, file: String = #file, line: Int = #line) -> FailureType {
34 | return Failure(reason: reason ?? "-", function: function, file: file, line: line)
35 | }
36 |
--------------------------------------------------------------------------------
/Linker/LinkerTests/Spectre/Global.swift:
--------------------------------------------------------------------------------
1 | #if os(Linux)
2 | import Glibc
3 | #else
4 | import Darwin
5 | #endif
6 |
7 |
8 | let globalContext: GlobalContext = {
9 | atexit { run() }
10 | return GlobalContext()
11 | }()
12 |
13 | public func describe(_ name: String, closure: (ContextType) -> Void) {
14 | globalContext.describe(name, closure: closure)
15 | }
16 |
17 | public func it(_ name: String, closure: @escaping () throws -> Void) {
18 | globalContext.it(name, closure: closure)
19 | }
20 |
21 | public func run() -> Never {
22 | let reporter: Reporter
23 |
24 | if CommandLine.arguments.contains("--tap") {
25 | reporter = TapReporter()
26 | } else if CommandLine.arguments.contains("-t") {
27 | reporter = DotReporter()
28 | } else {
29 | reporter = StandardReporter()
30 | }
31 |
32 | run(reporter: reporter)
33 | }
34 |
35 | public func run(reporter: Reporter) -> Never {
36 | if globalContext.run(reporter: reporter) {
37 | exit(0)
38 | }
39 | exit(1)
40 | }
41 |
--------------------------------------------------------------------------------
/Linker/LinkerTests/Spectre/GlobalContext.swift:
--------------------------------------------------------------------------------
1 | class GlobalContext {
2 | var cases = [CaseType]()
3 |
4 | func describe(_ name: String, closure: (ContextType) -> Void) {
5 | let context = Context(name: name)
6 | closure(context)
7 | cases.append(context)
8 | }
9 |
10 | func it(_ name: String, closure: @escaping () throws -> Void) {
11 | cases.append(Case(name: name, closure: closure))
12 | }
13 |
14 | func run(reporter: Reporter) -> Bool {
15 | return reporter.report { reporter in
16 | for `case` in cases {
17 | `case`.run(reporter: reporter)
18 | }
19 | }
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/Linker/LinkerTests/Spectre/Reporter.swift:
--------------------------------------------------------------------------------
1 | public protocol Reporter {
2 | /// Create a new report
3 | func report(closure: (ContextReporter) -> Void) -> Bool
4 | }
5 |
6 | public protocol ContextReporter {
7 | func report(_ name: String, closure: (ContextReporter) -> Void)
8 |
9 | /// Add a passing test case
10 | func addSuccess(_ name: String)
11 |
12 | /// Add a disabled test case
13 | func addDisabled(_ name: String)
14 |
15 | /// Adds a failing test case
16 | func addFailure(_ name: String, failure: FailureType)
17 | }
18 |
--------------------------------------------------------------------------------
/Linker/LinkerTests/Spectre/Reporters.swift:
--------------------------------------------------------------------------------
1 | import Foundation
2 | #if os(Linux)
3 | import Glibc
4 | #else
5 | import Darwin.C
6 | #endif
7 |
8 |
9 | enum ANSI : String, CustomStringConvertible {
10 | case Red = "\u{001B}[0;31m"
11 | case Green = "\u{001B}[0;32m"
12 | case Yellow = "\u{001B}[0;33m"
13 |
14 | case Bold = "\u{001B}[0;1m"
15 | case Reset = "\u{001B}[0;0m"
16 |
17 | static var supportsANSI: Bool {
18 | guard isatty(STDOUT_FILENO) != 0 else {
19 | return false
20 | }
21 |
22 | guard let termType = getenv("TERM") else {
23 | return false
24 | }
25 |
26 | guard String(cString: termType).lowercased() != "dumb" else {
27 | return false
28 | }
29 |
30 | return true
31 | }
32 |
33 | var description: String {
34 | if ANSI.supportsANSI {
35 | return rawValue
36 | }
37 |
38 | return ""
39 | }
40 | }
41 |
42 |
43 | struct CaseFailure {
44 | let position: [String]
45 | let failure: FailureType
46 |
47 | init(position: [String], failure: FailureType) {
48 | self.position = position
49 | self.failure = failure
50 | }
51 | }
52 |
53 |
54 | fileprivate func stripCurrentDirectory(_ file: String) -> String {
55 | var currentPath = FileManager.`default`.currentDirectoryPath
56 | if !currentPath.hasSuffix("/") {
57 | currentPath += "/"
58 | }
59 |
60 | if file.hasPrefix(currentPath) {
61 | return String(file.suffix(from: currentPath.endIndex))
62 | }
63 |
64 | return file
65 | }
66 |
67 |
68 | func printFailures(_ failures: [CaseFailure]) {
69 | for failure in failures {
70 | let name = failure.position.joined(separator: " ")
71 | Swift.print(ANSI.Red, name)
72 |
73 | let file = "\(stripCurrentDirectory(failure.failure.file)):\(failure.failure.line)"
74 | Swift.print(" \(ANSI.Bold)\(file)\(ANSI.Reset) \(ANSI.Yellow)\(failure.failure.reason)\(ANSI.Reset)\n")
75 |
76 | if let contents = try? String(contentsOfFile: failure.failure.file, encoding: String.Encoding.utf8) as String {
77 | let lines = contents.components(separatedBy: CharacterSet.newlines)
78 | let line = lines[failure.failure.line - 1]
79 | let trimmedLine = line.trimmingCharacters(in: CharacterSet.whitespaces)
80 | Swift.print(" ```")
81 | Swift.print(" \(trimmedLine)")
82 | Swift.print(" ```")
83 | }
84 | }
85 | }
86 |
87 |
88 | class CountReporter : Reporter, ContextReporter {
89 | var depth = 0
90 | var successes = 0
91 | var disabled = 0
92 | var position = [String]()
93 | var failures = [CaseFailure]()
94 |
95 | func printStatus() {
96 | printFailures(failures)
97 |
98 | let disabledMessage: String
99 | if disabled > 0 {
100 | disabledMessage = " \(disabled) skipped,"
101 | } else {
102 | disabledMessage = ""
103 | }
104 |
105 | if failures.count == 1 {
106 | print("\(successes) passes\(disabledMessage) and \(failures.count) failure")
107 | } else {
108 | print("\(successes) passes\(disabledMessage) and \(failures.count) failures")
109 | }
110 | }
111 |
112 | #if swift(>=3.0)
113 | func report(closure: (ContextReporter) -> Void) -> Bool {
114 | closure(self)
115 | printStatus()
116 | return failures.isEmpty
117 | }
118 | #else
119 | func report(@noescape _ closure: (ContextReporter) -> Void) -> Bool {
120 | closure(self)
121 | printStatus()
122 | return failures.isEmpty
123 | }
124 | #endif
125 |
126 | #if swift(>=3.0)
127 | func report(_ name: String, closure: (ContextReporter) -> Void) {
128 | depth += 1
129 | position.append(name)
130 | closure(self)
131 | depth -= 1
132 | position.removeLast()
133 | }
134 | #else
135 | func report(_ name: String, @noescape closure: (ContextReporter) -> Void) {
136 | depth += 1
137 | position.append(name)
138 | closure(self)
139 | depth -= 1
140 | position.removeLast()
141 | }
142 | #endif
143 |
144 | func addSuccess(_ name: String) {
145 | successes += 1
146 | }
147 |
148 | func addDisabled(_ name: String) {
149 | disabled += 1
150 | }
151 |
152 | func addFailure(_ name: String, failure: FailureType) {
153 | failures.append(CaseFailure(position: position + [name], failure: failure))
154 | }
155 | }
156 |
157 |
158 | /// Standard reporter
159 | class StandardReporter : CountReporter {
160 | override func report(_ name: String, closure: (ContextReporter) -> Void) {
161 | colour(.Bold, "-> \(name)")
162 | super.report(name, closure: closure)
163 | print("")
164 | }
165 |
166 | override func addSuccess(_ name: String) {
167 | super.addSuccess(name)
168 | colour(.Green, "-> \(name)")
169 | }
170 |
171 | override func addDisabled(_ name: String) {
172 | super.addDisabled(name)
173 | colour(.Yellow, "-> \(name)")
174 | }
175 |
176 | override func addFailure(_ name: String, failure: FailureType) {
177 | super.addFailure(name, failure: failure)
178 | colour(.Red, "-> \(name)")
179 | }
180 |
181 | func colour(_ colour: ANSI, _ message: String) {
182 | let indentation = String(repeating: " ", count: depth * 2)
183 | print("\(indentation)\(colour)\(message)\(ANSI.Reset)")
184 | }
185 | }
186 |
187 |
188 | /// Simple reporter that outputs minimal . F and S.
189 | class DotReporter : CountReporter {
190 | override func addSuccess(_ name: String) {
191 | super.addSuccess(name)
192 | print(ANSI.Green, ".", ANSI.Reset, separator: "", terminator: "")
193 | }
194 |
195 | override func addDisabled(_ name: String) {
196 | super.addDisabled(name)
197 | print(ANSI.Yellow, "S", ANSI.Reset, separator: "", terminator: "")
198 | }
199 |
200 | override func addFailure(_ name: String, failure: FailureType) {
201 | super.addFailure(name, failure: failure)
202 | print(ANSI.Red, "F", ANSI.Reset, separator: "", terminator: "")
203 | }
204 |
205 | override func printStatus() {
206 | print("\n")
207 | super.printStatus()
208 | }
209 | }
210 |
211 |
212 | /// Test Anything Protocol compatible reporter
213 | /// http://testanything.org
214 | class TapReporter : CountReporter {
215 | var count = 0
216 |
217 | override func addSuccess(_ name: String) {
218 | count += 1
219 | super.addSuccess(name)
220 |
221 | let message = (position + [name]).joined(separator: " ")
222 | print("ok \(count) - \(message)")
223 | }
224 |
225 | override func addDisabled(_ name: String) {
226 | count += 1
227 | super.addDisabled(name)
228 |
229 | let message = (position + [name]).joined(separator: " ")
230 | print("ok \(count) - # skip \(message)")
231 | }
232 |
233 | override func addFailure(_ name: String, failure: FailureType) {
234 | count += 1
235 | super.addFailure(name, failure: failure)
236 |
237 | let message = (position + [name]).joined(separator: " ")
238 | print("not ok \(count) - \(message)")
239 | print("# \(failure.reason) from \(stripCurrentDirectory(failure.file)):\(failure.line)")
240 | }
241 |
242 | override func printStatus() {
243 | print("\(min(1, count))..\(count)")
244 | }
245 | }
246 |
--------------------------------------------------------------------------------
/Linker/Sources/Linker/Linker.swift:
--------------------------------------------------------------------------------
1 | //
2 | // Linker.swift
3 | // Linker
4 | //
5 | // Created by Maksim Kurpa on 1/16/18.
6 | // Copyright © 2018 Maksim Kurpa. All rights reserved.
7 | //
8 |
9 | import UIKit
10 | import CoreFoundation
11 |
12 | open class Linker: NSObject {
13 |
14 | open class func handle(_ url: URL, closure: @escaping (_ url: URL) -> Void) {
15 | _ = swizzleOnce
16 | let key = url.key()
17 | closuresDict[key] = closure
18 | }
19 |
20 | fileprivate static var handlingURL : URL?
21 |
22 | fileprivate static func models(execution: @escaping ExecutionClosureType) -> [LNModel] {
23 | return Array(arrayLiteral:
24 | LNModel(clss:type(of: UIApplication.shared),
25 | selector:NSSelectorFromString("openURL:options:completionHandler:"),
26 | execution: execution),
27 | LNModel(clss:type(of: UIApplication.shared),
28 | selector:NSSelectorFromString("openURL:"),
29 | execution: execution),
30 | LNModel(clss:type(of: UIApplication.shared.delegate!),
31 | selector:NSSelectorFromString("application:openURL:options:"),
32 | execution: execution),
33 | LNModel(clss:type(of: UIApplication.shared.delegate!),
34 | selector:NSSelectorFromString("application:openURL:sourceApplication:annotation:"),
35 | execution: execution),
36 | LNModel(clss:type(of: UIApplication.shared.delegate!),
37 | selector:NSSelectorFromString("application:handleOpenURL:"),
38 | execution: execution)
39 | )}
40 |
41 | internal static func swizzleFunc(clss: AnyClass, selector: Selector, execution: Any) -> Void{
42 |
43 | let replaceMethod = class_getInstanceMethod(Linker.self, #selector(Linker.fakeMethod))
44 | var method: Method? = class_getInstanceMethod(clss, selector)
45 | if method == nil {
46 | class_addMethod(clss, selector, method_getImplementation(replaceMethod!), nil)
47 | method = class_getInstanceMethod(clss, selector)
48 | }
49 |
50 | let executionIMP : IMP?
51 | let argumentsCount = selector.argumentsCount() + 1//- because val0 always object which receive a message
52 |
53 | switch argumentsCount {
54 | case 2:
55 | let closure: ObjcBlockType_2 = {val0, val1 in
56 | (execution as! (AnyObject, AnyObject) -> Void)(val0, val1)
57 | }
58 | executionIMP = imp_implementationWithBlock(closure)
59 | case 3:
60 | let closure: ObjcBlockType_3 = {val0, val1, val2 in
61 | (execution as! (AnyObject, AnyObject, AnyObject) -> Void)(val0, val1, val2)
62 | }
63 | executionIMP = imp_implementationWithBlock(closure)
64 | case 4:
65 | let closure: ObjcBlockType_4 = {val0, val1, val2, val4 in
66 | (execution as! (AnyObject, AnyObject, AnyObject, AnyObject) -> Void)(val0, val1, val2, val4)
67 | }
68 | executionIMP = imp_implementationWithBlock(closure)
69 | case 5:
70 | let closure: ObjcBlockType_5 = {val0, val1, val2, val4, val5 in
71 | (execution as! (AnyObject, AnyObject, AnyObject, AnyObject, AnyObject) -> Void)(val0, val1, val2, val4, val5)
72 | }
73 | executionIMP = imp_implementationWithBlock(closure)
74 | default:
75 | assert(true, "method has more then 4 arguments")
76 | return
77 | }
78 |
79 | method_setImplementation(replaceMethod!, executionIMP!)
80 | method_exchangeImplementations(method!, replaceMethod!)
81 | }
82 |
83 | fileprivate static var swizzleOnce: Void = {
84 |
85 | let execution: (URL) -> (URL?) = {url in
86 | return Linker.handle(url)
87 | }
88 | for swizzleClosure in models(execution: execution) {
89 | swizzleFunc(clss: swizzleClosure.clss, selector: swizzleClosure.selector, execution: swizzleClosure.execution as Any)
90 | }
91 | }()
92 |
93 | @objc fileprivate func fakeMethod() -> Void {
94 | }
95 |
96 | static fileprivate var closuresDict: [String : LinkerClosureType] = {
97 | return [:] }()
98 |
99 |
100 | fileprivate class func handle(_ url: URL) -> URL? {
101 |
102 | let urlStringKey: String = url.key()
103 | let closure: LinkerClosureType? = closuresDict[urlStringKey]
104 |
105 | guard let execution = closure else {
106 | return url
107 | }
108 |
109 | if self.handlingURL != nil {
110 | if url == self.handlingURL! {
111 | return nil
112 | }
113 | }
114 | self.handlingURL = url
115 | self.handleIfAppIsLoaded(withConmplitionBlock: {() -> Void in
116 | execution(url)
117 | })
118 | return nil
119 | }
120 |
121 | fileprivate class func handleIfAppIsLoaded(withConmplitionBlock complitionBlock: @escaping () -> ()) {
122 | if UIApplication.shared.applicationState == .active {
123 | self.handlingURL = nil
124 | complitionBlock()
125 | } else {
126 | var observer : Any? = nil
127 | observer = NotificationCenter.default.addObserver(forName: .UIApplicationDidBecomeActive, object: nil, queue: OperationQueue.main, using: {(_ note: Notification) -> Void in
128 | self.handlingURL = nil
129 | complitionBlock()
130 | NotificationCenter.default.removeObserver(observer!)
131 | observer = nil
132 | })
133 | }
134 | }
135 | }
136 |
--------------------------------------------------------------------------------
/Linker/Sources/Linker/LinkerExtensions.swift:
--------------------------------------------------------------------------------
1 | //
2 | // LinkerUtils.swift
3 | // Linker
4 | //
5 | // Created by Maksim Kurpa on 2/2/18.
6 | // Copyright © 2018 Maksim Kurpa. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | extension Selector {
12 | public func argumentsCount()-> Int {
13 | let stringSelector = NSStringFromSelector(self);
14 | if !stringSelector.contains(":") {
15 | return 0
16 | }
17 | let colons: String = stringSelector.filter({
18 | return (":" == $0)
19 | })
20 | return colons.count
21 | }
22 |
23 | public func indexOfArgument(withName name: String) -> Int? {
24 | let subStrings = NSStringFromSelector(self).split(separator: ":", maxSplits: NSIntegerMax, omittingEmptySubsequences: false)
25 | for subString in subStrings {
26 | if (subString.contains(name)) {
27 | return subStrings.index(of: subString)
28 | }
29 | }
30 | return nil
31 | }
32 | }
33 |
34 | extension URL {
35 | public func key() -> String {
36 | let components = URLComponents(url: self, resolvingAgainstBaseURL: true)
37 | return "\(components?.scheme ?? "")://\(components?.host ?? "")"
38 | }
39 | }
40 |
41 |
42 |
--------------------------------------------------------------------------------
/Linker/Sources/Linker/LinkerModel.swift:
--------------------------------------------------------------------------------
1 | //
2 | // LNModel.swift
3 | // Linker
4 | //
5 | // Created by Maksim Kurpa on 1/23/18.
6 | // Copyright © 2018 Maksim Kurpa. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | internal struct LNModel {
12 |
13 | init(clss: AnyClass, selector: Selector, execution:@escaping ExecutionClosureType ) {
14 |
15 | let method: Method? = class_getInstanceMethod(clss, selector);
16 | var originalIMP : IMP? = nil
17 | if let originalMethod = method {
18 | originalIMP = method_getImplementation(originalMethod);
19 | }
20 |
21 | let argumentsCount = selector.argumentsCount() + 1 //because first parament is always self object
22 | let sourceParameterIndex = selector.indexOfArgument(withName: "URL")
23 |
24 | switch argumentsCount {
25 | case 2:
26 | let closure: ClosureType_2 = {val0, val1 in
27 |
28 | let urlDidntHandle = execution(val1 as! URL)
29 | if let _ = urlDidntHandle, let _ = originalIMP{
30 | let curriedImplementation = unsafeBitCast(originalIMP, to: FuncCType_2.self)
31 | curriedImplementation(val0, selector,val1)
32 | }
33 | }
34 | self._execution = closure as AnyObject
35 | case 3:
36 | let closure: ClosureType_3 = {val0, val1, val2 in
37 | guard let sourceIndex = sourceParameterIndex else {
38 | return
39 | }
40 | let urlDidntHandle = execution(sourceIndex == 0 ? val1 as! URL : val2 as! URL)
41 | if let _ = urlDidntHandle, let _ = originalIMP{
42 | let curriedImplementation = unsafeBitCast(originalIMP, to: FuncCType_3.self)
43 | curriedImplementation(val0, selector,val1, val2)
44 | }
45 | }
46 | self._execution = closure as AnyObject
47 | case 4:
48 | let closure: ClosureType_4 = {val0, val1, val2, val3 in
49 | guard let sourceIndex = sourceParameterIndex else {
50 | return
51 | }
52 | let urlDidntHandle = execution(sourceIndex == 0 ? val1 as! URL : sourceIndex == 1 ? val2 as! URL : val3 as! URL)
53 | if let _ = urlDidntHandle, let _ = originalIMP{
54 | let curriedImplementation = unsafeBitCast(originalIMP, to: FuncCType_4.self)
55 | curriedImplementation(val0, selector,val1, val2, val3)
56 | }
57 | }
58 | self._execution = closure as AnyObject
59 | case 5:
60 | let closure: ClosureType_5 = {val0, val1, val2, val3, val4 in
61 | guard let sourceIndex = sourceParameterIndex else {
62 | return
63 | }
64 | let urlDidntHandle = execution(sourceIndex == 0 ? val1 as! URL : sourceIndex == 1 ? val2 as! URL : sourceIndex == 2 ? val3 as! URL : val4 as! URL)
65 | if let _ = urlDidntHandle, let _ = originalIMP{
66 | let curriedImplementation = unsafeBitCast(originalIMP, to: FuncCType_5.self)
67 | curriedImplementation(val0, selector,val1, val2, val3, val4)
68 | }
69 | }
70 | self._execution = closure as AnyObject
71 | default:
72 | self._execution = nil
73 | }
74 | _clss = clss
75 | _selector = selector
76 | }
77 |
78 | //MARK: - Properties
79 |
80 | public var selector: Selector {
81 | return _selector
82 | }
83 | public var clss: AnyClass {
84 | return _clss
85 | }
86 | public var execution: AnyObject? {
87 | return _execution
88 | }
89 |
90 | fileprivate var _selector: Selector;
91 | fileprivate var _clss: AnyClass
92 | fileprivate var _execution: AnyObject?;
93 | }
94 |
--------------------------------------------------------------------------------
/Linker/Sources/Linker/LinkerTypes.swift:
--------------------------------------------------------------------------------
1 | //
2 | // LinkerTypes.swift
3 | // Linker
4 | //
5 | // Created by Maksim Kurpa on 1/26/18.
6 | // Copyright © 2018 Maksim Kurpa. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | typealias LinkerClosureType = (_ url: URL) -> Void
12 | typealias ExecutionClosureType = (URL) -> (URL?)?
13 |
14 | typealias ClosureType_2 = (AnyObject, AnyObject) -> Void
15 | typealias ClosureType_3 = (AnyObject, AnyObject, AnyObject) -> Void
16 | typealias ClosureType_4 = (AnyObject, AnyObject, AnyObject, AnyObject) -> Void
17 | typealias ClosureType_5 = (AnyObject, AnyObject, AnyObject, AnyObject, AnyObject) -> Void
18 |
19 | typealias FuncCType_2 = @convention(c) (AnyObject, Selector ,AnyObject) -> Void
20 | typealias FuncCType_3 = @convention(c) (AnyObject, Selector ,AnyObject, AnyObject) -> Void
21 | typealias FuncCType_4 = @convention(c) (AnyObject, Selector ,AnyObject, AnyObject, AnyObject) -> Void
22 | typealias FuncCType_5 = @convention(c) (AnyObject, Selector ,AnyObject, AnyObject, AnyObject, AnyObject) -> Void
23 |
24 | typealias ObjcBlockType_2 = @convention(block) (AnyObject, AnyObject) -> Void
25 | typealias ObjcBlockType_3 = @convention(block) (AnyObject, AnyObject, AnyObject) -> Void
26 | typealias ObjcBlockType_4 = @convention(block) (AnyObject, AnyObject, AnyObject, AnyObject) -> Void
27 | typealias ObjcBlockType_5 = @convention(block) (AnyObject, AnyObject, AnyObject, AnyObject, AnyObject) -> Void
28 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
2 | 
3 |
Linker
4 | Lightweight way to handle internal and external deeplinks in Swift for iOS.
5 |
6 | 
7 | 
8 | 
9 | 
10 | 
11 | 
12 |
13 |
14 |
15 |
16 | ---
17 |
18 |
19 | ## Installation
20 |
21 | ### Dependency Managers
22 |
23 | CocoaPods
24 |
25 | [CocoaPods](http://cocoapods.org) is a dependency manager for Cocoa projects. You can install it with the following command:
26 |
27 | ```bash
28 | $ gem install cocoapods
29 | ```
30 |
31 | To integrate Linker into your Xcode project using CocoaPods, specify it in your `Podfile`:
32 |
33 | ```ruby
34 | source 'https://github.com/CocoaPods/Specs.git'
35 | platform :ios, '8.0'
36 | use_frameworks!
37 |
38 | pod 'Linker'
39 | ```
40 |
41 | Then, run the following command:
42 |
43 | ```bash
44 | $ pod install
45 | ```
46 |
47 |
48 |
49 |
50 | Carthage
51 |
52 | [Carthage](https://github.com/Carthage/Carthage) is a decentralized dependency manager that automates the process of adding frameworks to your Cocoa application.
53 |
54 | You can install Carthage with [Homebrew](http://brew.sh/) using the following command:
55 |
56 | ```bash
57 | $ brew update
58 | $ brew install carthage
59 | ```
60 |
61 | To integrate Linker into your Xcode project using Carthage, specify it in your `Cartfile`:
62 |
63 | ```ogdl
64 | github "Linker"
65 | ```
66 |
67 |
68 |
69 | ## Usage
70 |
71 | (see sample Xcode project Demo)
72 |
73 | The main thought of this framework is useful and convenient handling of external and internal URLs in your iOS application. Linker provides only one function to install your own handler to specific URL. A dependency between specific URL and your closure is based on `scheme` and `host` of each URL. That is you can configure miscellaneous behavior for different components of specific URL. You can split handling by `query` with different parameters and/or by `path`, `fragment`.
74 |
75 |
76 | Realization details
77 | On start of your application occurs swizzling methods in `UIApplication` and `UIApplicationDelegate` of your application. Original implementation exchanged on Linker's implementation, where occur handle process. If Linker can't handle specific URL, original implementation of this method will be called.
78 |
79 | Swizzled functions:
80 |
81 | `UIApplication.shared - openURL:options:completionHandler:`
82 |
83 | `UIApplication.shared - openURL:` (deprecated since iOS 10.0)
84 |
85 | `UIApplication.shared.delegate - application:openURL:options:`
86 |
87 | `UIApplication.shared.delegate - application:openURL:sourceApplication:annotation:` (deprecated since iOS 9.0)
88 |
89 | `UIApplication.shared.delegate - application:handleOpenURL:` (deprecated since iOS 9.0)
90 |
91 |
92 | For complience with URL style, use format:
93 |
94 | `your_app_url_scheme://inapp_am/buy_subscription?type=subscription&productID=com.yourapp.7days_trial#test`
95 |
96 | where:
97 |
98 | scheme - `your_app_url_scheme`,
99 |
100 | host - `inapp_am`,
101 |
102 | path - `buy_subscription`
103 |
104 | query - `type=subscription&productID=com.yourapp.7days_trial`
105 |
106 | fragment - `test`
107 |
108 | If you don't need configuration with complexed behavior, you can use URL just with `host`:
109 |
110 | `your_app_url_scheme://some_host_from_your_app`
111 |
112 | One special case - handle external URLs when app isn't launched. You should install closure for specific URL and if this url will be in pair with `UIApplicationLaunchOptionsKey` in `launchOptions` - this url will be handled.
113 |
114 | ```Swift
115 | func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool
116 | {
117 | let launchURL = URL(string: "linker://launchURL")!
118 |
119 | //if launchUrl equal launchOptions?[UIApplicationLaunchOptionsKey.url] -> this closure will be handled after app launch
120 | Linker.handle(launchURL, closure: { url in
121 | print("Your URL has been handle!")
122 | })
123 | return true
124 | }
125 | ```
126 | In other cases of usage you should set your handle closure for special URL before calling its from somewhere. If you have a few places where you need handle one specific url, you should reassign closure where latest set closure should have right `context`.
127 |
128 |
129 | (!) Notice: Only the last sent closure for a unique URL (scheme + host) will be executed.
130 |
131 | ```Swift
132 | class ViewController: UIViewController {
133 |
134 | let sourceURL = URL(string: "linker://viewcontroller?title=ExampleAlert&description=ExampleDescriptionAlert")!
135 |
136 | @IBAction func action(_ sender: Any) {
137 | UIApplication.shared.open(sourceURL, options: [:], completionHandler: nil)
138 | }
139 |
140 | override func viewDidLoad() {
141 | super.viewDidLoad()
142 | Linker.handle(sourceURL) { url in
143 |
144 | guard let queryItems = URLComponents(url: url, resolvingAgainstBaseURL: true)?.queryItems! else {
145 | return }
146 | var title : String? = nil
147 | var description: String? = nil
148 |
149 | for item in queryItems {
150 | if item.name == "title" {
151 | title = item.value
152 | }
153 | if item.name == "description" {
154 | description = item.value;
155 | }
156 | }
157 |
158 | if let name = title, let message = description {
159 | let alertVC = UIAlertController(title: name, message: message, preferredStyle: UIAlertControllerStyle.alert)
160 | alertVC.addAction(UIAlertAction(title: "Cancel", style: UIAlertActionStyle.cancel, handler: {action in
161 | alertVC.dismiss(animated: true, completion: nil)
162 | }))
163 | self.present(alertVC, animated: false, completion: nil)
164 | }
165 | }
166 | }
167 | }
168 | ```
169 | You can also find Objective-C version of this [here](https://github.com/MaksimKurpa/DeepLinksHandler).
170 |
171 | ## Contributing
172 |
173 | Issues and pull requests are welcome!
174 |
175 | ## Author
176 |
177 | Maksim Kurpa - [@maksim_kurpa](https://twitter.com/maksim_kurpa)
178 |
179 | ## License
180 |
181 | This code is distributed under the terms and conditions of the [MIT license](https://raw.githubusercontent.com/MaksimKurpa/Linker/master/LICENSE).
182 |
--------------------------------------------------------------------------------