Slide 1
Slide 1 text
APIKit Tips
@matuyuji
2015.8.26
ؔϞόΠϧΞϓϦݚڀձ #5
Slide 2
Slide 2 text
@matuyuji
safx-dev.blogspot.jp
Slide 3
Slide 3 text
ishkawa/APIKit
let request = SomeRequest(…)
API.sendRequest(request) { result in
switch result {
case .Success(let response):
:
case .Failure(let error):
:
}
}
Slide 4
Slide 4 text
let request = FooListRequest(…)
API.sendRequest(request) { result in
switch result {
case .Success(let response):
:
case .Failure(let error):
:
}
}
public protocol Request {
typealias Response
:
}
ϓϩτίϧϕʔεͷ࣮
(σϑΥϧτ࣮͋Γ)
struct FooListRequest: Request {
typealias Response = [Foo]
var path: String { return “list" }
:
}
ϨεϙϯεͷܕΛਪՄೳ
init࣌ʹσϑΥϧτΛઃఆՄೳ
staticΦϒδΣΫτͳͷͰextensionͰมͷՃ͕Մೳ
Slide 5
Slide 5 text
safx/SlackKit
SlackAPI.send(auth.test(token: token)) { result in
switch result {
case .Success(let res) : print(res)
case .Failure(let error): print(error)
}
}
testResponse(
url=https://foobar-inc.slack.com/,
team=foobar-inc,
user=john,
teamId=T0*******,
userId=U0*******
)
Slide 6
Slide 6 text
safx/swift-idl
enum channels {
struct list: ClassInit, APIKitHelper, SlackRequest { // router:",channels.list"
typealias APIKitResponse = ChannelsResult
let token: Token
let excludeArchived: Int = 0 // json:"exclude_archived"
}
}
public struct list: SlackRequest {
public typealias APIKitResponse = ChannelsResult
public let token: Token
public let excludeArchived: Int
public init(token: Token, excludeArchived: Int = 0) {
self.token = token
self.excludeArchived = excludeArchived
}
public var method: HTTPMethod { return .GET }
public var path: String { return “channels.list" }
public var parameters: [String: AnyObject] {
return ["token": token.toJSON(),
“exclude_archived": excludeArchived.toJSON()] }
}
Slide 7
Slide 7 text
Slack API
{
"ok": true,
"url": "https://foobar.slack.com/",
"team": "foobar",
"user": "john",
"team_id": “T0*******”,
"user_id": “U0*******”
}
{
"ok": false,
"error": "not_authed"
}
Slide 8
Slide 8 text
APIKitRequest
public protocol APIKitRequest: Request {
typealias APIKitResponse
typealias Response = SimpleResult
}
public protocol SlackRequest: APIKitRequest {}
public protocol SlackOAuthRequest: APIKitRequest {}
public enum SimpleResult {
case OK(Type)
case Error(SlackError)
}
Slide 9
Slide 9 text
extension APIKitRequest where
Self.APIKitResponse: JSONDecodable,
Self.APIKitResponse == Self.APIKitResponse.DecodedType {
public func responseFromObject(object: AnyObject,
URLResponse: NSHTTPURLResponse) -> SimpleResult? {
guard let ok = object["ok"] as? Bool else { return nil }
if !ok {
guard let error = object["error"] as? String else { return nil }
return .Error(SlackError(rawText: error))
}
do {
return .OK(try Self.APIKitResponse.parseJSON(object))
} catch {
return .Error(.JSONError(error))
}
}
}
Slide 10
Slide 10 text
Result, APIError>
SlackAPI.sendRequest(auth.test(token: token)) { result in
switch result {
case .Success(let res):
switch res {
case .OK(let r): print(r)
case .Error(let err): print(err)
}
case .Failure(let error): print(error)
}
}
Slide 11
Slide 11 text
SlackAPI.send
extension SlackAPI {
public class func send(request: T, URLSession: NSURLSession =
defaultURLSession, handler: (Result) -> Void = {r
in}) -> NSURLSessionDataTask? {
func trampoline(handler: (Result) -> Void)
(result: Result) {
switch result {
case .Success(let some):
switch some.result {
case .OK(let res):
handler(.Success(res))
case .Error(let err):
handler(.Failure(err))
}
case .Failure(let error):
handler(.Failure(.OtherError(error)))
}
}
return sendRequest(request, URLSession: URLSession,
handler: trampoline(handler))
}
}
Slide 12
Slide 12 text
public protocol SimpleResultType {
typealias Element
var result: SimpleResult { get }
}
public protocol APIKitRequest: Request {
typealias APIKitResponse
typealias Response = SimpleResult
}