Octokit.swift

安装

• 使用 Swift Package Manager:

import PackageDescription

let package = Package(
  name: "MyAwesomeApp",
    dependencies: [
      .package(url: "https://github.com/nerdishbynature/octokit.swift", from: "0.11.0"),
    ]
  )

认证

Octokit 同时支持 GitHub 和 GitHub Enterprise。 认证是通过配置来处理的。

有两种类型的配置：TokenConfiguration 和 OAuthConfiguration。

TokenConfiguration

当你使用基于访问令牌的认证（例如用户在网站上生成并提供给你一个访问令牌）或者你通过 OAuth 流程获得了访问令牌时，可以使用 TokenConfiguration。

你可以为 github.com 初始化一个新的配置，如下所示：

let config = TokenConfiguration("你的私人GitHub令牌")

或者对于 GitHub Enterprise：

let config = TokenConfiguration("你的私人GitHub令牌", url: "https://github.example.com/api/v3/")

获得令牌后，你可以将其与 Octokit 一起使用：

Octokit(config).me() { response in
  switch response {
  case .success(let user):
    print(user.login as Any)
  case .failure(let error):
    print(error)
  }
}

OAuthConfiguration

当你还没有访问令牌，需要用户登录你的应用时，可以使用 OAuthConfiguration。这也处理 OAuth 流程。

你可以为 github.com 认证用户，如下所示：

let config = OAuthConfiguration(token: "<你的客户端ID>", secret: "<你的客户端密钥>", scopes: ["repo", "read:org"])
let url = config.authenticate()

或者对于 GitHub Enterprise：

let config = OAuthConfiguration("https://github.example.com/api/v3/", webURL: "https://github.example.com/", token: "<你的客户端ID>", secret: "<你的客户端密钥>", scopes: ["repo", "read:org"])

获得配置后，你可以认证用户：

// AppDelegate.swift

config.authenticate()

func application(application: UIApplication, openURL url: NSURL, sourceApplication: String?, annotation: AnyObject?) -> Bool {
  config.handleOpenURL(url) { config in
    self.loadCurrentUser(config) // 当然，这完全是可选的
  }
  return false
}

func loadCurrentUser(config: TokenConfiguration) {
  Octokit(config).me() { response in
    switch response {
    case .success(let user):
      print(user.login)
    case .failure(let error):
      print(error)
    }
  }
}

请注意，OAuth 流程完成后，你会得到一个 TokenConfiguration。 你需要自己存储 accessToken。如果你想进行进一步的请求，没有必要再次进行 OAuth 流程。你可以直接使用 TokenConfiguration。

let token = // 从你的钥匙串、用户默认设置（不推荐）等获取你的令牌
let config = TokenConfiguration(token)
Octokit(config).user(name: "octocat") { response in
  switch response {
  case .success(let user):
  	print("用户登录名: \(user.login!)")
  case .failure(let error):
  	print("错误: \(error)")
  }
}

用户

获取单个用户

let username = ... // 设置用户名
Octokit().user(name: username) { response in
  switch response {
    case .success(let user):
      // 对用户进行操作
    case .failure(let error):
      // 处理任何错误
  }
}

获取已认证的用户

Octokit().me() { response in
  switch response {
    case .success(let user):
      // 对用户进行操作
    case .failure(let error):
      // 处理任何错误
  }

仓库

获取单个仓库

let (owner, name) = ("所有者", "名称") // 替换为实际的所有者和名称
Octokit().repository(owner, name) { response in
  switch response {
    case .success(let repository):
      // 对仓库进行操作
    case .failure(let error):
      // 处理任何错误
  }
}

获取已认证用户的仓库

Octokit().repositories() { response in
  switch response {
    case .success(let repository):
      // 进行操作
    case .failure(let error):
      // 处理任何错误
  }
}

已加星标的仓库

获取某个用户已加星标的仓库

let username = "用户名"
Octokit().stars(username) { response in
  switch response {
    case .success(let repositories):
      // 对仓库进行操作
    case .failure(let error):
      // 处理任何错误
  }
}

获取已认证用户已加星标的仓库

Octokit().myStars() { response in
  switch response {
    case .success(let repositories):
      // 对仓库进行操作
    case .failure(let error):
      // 处理任何错误
  }
}

关注者和正在关注

获取某个用户的关注者

let username = "用户名"
Octokit().followers(username) { response in
  switch response {
    case .success(let users):
      // 对用户进行操作
    case .failure(let error):
      // 处理任何错误
  }
}

获取已认证用户的关注者

Octokit().myFollowers() { response in
  switch response {
    case .success(let users):
      // 对用户进行操作
    case .failure(let error):
      // 处理任何错误
  }
}

获取某个用户正在关注的人

let username = "用户名"
Octokit().following(username) { response in
  switch response {
    case .success(let users):
      // 对用户进行操作
    case .failure(let error):
      // 处理任何错误
  }
}

获取已认证用户正在关注的人

Octokit().myFollowing() { response in
  switch response {
    case .success(let users):
      // 对用户进行操作
    case .failure(let error):
      // 处理任何错误
  }
}

问题

获取已认证用户的问题

获取已认证用户在所有可见仓库中的所有问题，包括拥有的仓库、成员仓库和组织仓库。

Octokit(config).myIssues() { response in
    switch response {
        case .success(let issues):
        // 对问题进行操作
    case .failure:
        // 处理任何错误
    }   
}

获取单个问题

let (owner, repo, number) = ("所有者", "仓库", 1347) // 替换为实际的所有者、仓库名和问题编号
Octokit(config).issue(owner, repository: repo, number: number) { response in
    switch response {
    case .success(let issue):
        // 处理问题
    case .failure:
        // 处理错误
    }
}

创建新问题

Octokit(config).postIssue("所有者", repository: "仓库", title: "发现了一个bug", body: "我遇到了一个问题。", assignee: "octocat", labels: ["bug", "重复"]) { response in
    switch response {
    case .success(let issue):
        // 处理问题
    case .failure:
        // 处理错误
    }
}

编辑现有问题

Octokit(config).patchIssue("所有者", repository: "仓库", number: 1347, title: "发现了一个bug", body: "我遇到了一个问题。", assignee: "octocat", state: .Closed) { response in
    switch response {
    case .success(let issue):
        // 处理问题
    case .failure:
        // 处理错误
    }
}

评论问题

Octokit().commentIssue(owner: "octocat", repository: "Hello-World", number: 1, body: "测试评论") { response in
    switch response {
    case .success(let comment):
        // 处理评论
    case .failure:
        // 处理错误
    }
}

编辑现有评论

Octokit().patchIssueComment(owner: "octocat", repository: "Hello-World", number: 1, body: "测试评论") { response in
    switch response {
    case .success(let comment):
        // 处理评论
    case .failure:
        // 处理错误
    }
}

拉取请求

获取单个拉取请求

Octokit().pullRequest(owner: "octocat", repository: "Hello-World", number: 1) { response in
    switch response {
        case .success(let pullRequests):
            // 处理拉取请求
        case .failure:
            // 处理错误
     }
}

列出拉取请求

Octokit().pullRequests(owner: "octocat", repository: "Hello-World", base: "develop", state: Openness.Open) { response in
    switch response {
        case .success(let pullRequests):
        // 处理拉取请求列表
        case .failure:
        // 处理错误
    }
}

更新现有拉取请求

Octokit().patchPullRequest(session, owner: "octocat", repository: "Hello-World", number: 1, title: "更新的标题", body: "更新的内容", state: .open, base: "base-branch", mantainerCanModify: true) { response in
    switch response {
        case .success(let pullrequest):
        // 处理拉取请求
        case .failure:
        // 处理错误
    }
}

发布

创建新发布

Octokit().postRelease(owner: "octocat", repository: "Hello-World", tagName: "v1.0.0", targetCommitish: "master", name: "v1.0.0 发布", body: "此版本的更新日志", prerelease: false, draft: false) { response in
	switch response {
        case .success(let release):
        // 处理发布
        case .failure:
        // 处理错误
    }
}