re-import XCFramework to make xcode shut up about file not being found

change lib paths to produce libgit2.a for both simulator and device
combine fat binaries for simulator with XCFramework for sim + iphone
2023-10-17 16:43:58 +02:00 · 2023-10-17 16:43:58 +02:00 · 2023-10-17 16:43:58 +02:00 · 2023-10-17 16:43:58 +02:00 · 2023-10-17 16:43:58 +02:00 · 2023-10-17 16:43:58 +02:00
72 changed files with 3776 additions and 2017 deletions
@@ -1,3 +1,6 @@
+.vscode/
+.build/
+
 # Xcode
 #
 build/
@@ -16,6 +19,28 @@ DerivedData
 *.hmap
 *.ipa
 *.xcuserstate
+*.xcscmblueprint
+*.idea*

 External/libgit2*.a
+External/libgit2-mac
+External/ios-openssl
+External/libgit2-ios
+External/libssh2-ios

+### fastlane ###
+# fastlane - A streamlined workflow tool for Cocoa deployment
+
+# fastlane specific
+fastlane/report.xml
+
+# deliver temporary files
+fastlane/Preview.html
+
+# snapshot generated screenshots
+fastlane/screenshots/**/*.png
+fastlane/screenshots/screenshots.html
+
+# scan temporary files
+fastlane/test_output
+test_output
@@ -1,9 +1,6 @@
 [submodule "External/libgit2"]
 	path = External/libgit2
 	url = https://github.com/libgit2/libgit2.git
-[submodule "Carthage/Checkouts/Guanaco"]
-	path = Carthage/Checkouts/Guanaco
-	url = https://github.com/modocache/Guanaco.git
 [submodule "Carthage/Checkouts/Nimble"]
 	path = Carthage/Checkouts/Nimble
 	url = https://github.com/Quick/Nimble.git
@@ -13,6 +10,14 @@
 [submodule "Carthage/Checkouts/xcconfigs"]
 	path = Carthage/Checkouts/xcconfigs
 	url = https://github.com/jspahrsummers/xcconfigs.git
-[submodule "Carthage/Checkouts/Result"]
-	path = Carthage/Checkouts/Result
-	url = https://github.com/antitypical/Result.git
+[submodule "Carthage/Checkouts/ZipArchive"]
+	path = Carthage/Checkouts/ZipArchive
+	url = https://github.com/ZipArchive/ZipArchive.git
+[submodule "External/libssh2"]
+	path = External/libssh2
+	url = https://github.com/libssh2/libssh2.git
+[submodule "External/openssl"]
+	path = External/openssl
+	url = https://github.com/openssl/openssl.git
+[submodule "libgit2"]
+	url = https://github.com/libgit2/libgit2.git
@@ -0,0 +1,4 @@
+# Configuration for Hound (https://houndci.com)
+
+swiftlint:
+  config_file: .swiftlint.yml
@@ -0,0 +1,79 @@
+disabled_rules:
+  - file_length
+  - force_cast
+  - force_try
+  - function_body_length
+  - identifier_name
+  - redundant_optional_initialization
+  - type_body_length
+
+opt_in_rules:
+  - array_init
+  - attributes
+  - closure_end_indentation
+  - closure_spacing
+  - collection_alignment
+  - conditional_returns_on_newline
+  - contains_over_first_not_nil
+  - convenience_type
+  - discouraged_object_literal
+  - discouraged_optional_boolean
+  - discouraged_optional_collection
+  - empty_count
+  - empty_string
+  - empty_xctest_method
+  - explicit_enum_raw_value
+  - explicit_init
+  - extension_access_modifier
+  - fallthrough
+  - fatal_error_message
+  - first_where
+  - function_default_parameter_at_end
+  - identical_operands
+  - implicitly_unwrapped_optional
+  - joined_default_parameter
+  - last_where
+  - legacy_random
+  - literal_expression_end_indentation
+  - lower_acl_than_parent
+  - modifier_order
+  - multiline_arguments
+  - multiline_function_chains
+  - multiline_literal_brackets
+  - nslocalizedstring_key
+  - overridden_super_call
+  - override_in_extension
+  - private_action
+  - private_outlet
+  - prohibited_super_call
+  - quick_discouraged_call
+  - quick_discouraged_focused_test
+  - quick_discouraged_pending_test
+  - redundant_nil_coalescing
+  - redundant_type_annotation
+  - sorted_first_last
+  - static_operator
+  - strict_fileprivate
+  - switch_case_on_newline
+  - toggle_bool
+  - unavailable_function
+  - untyped_error_in_catch
+  - unused_import
+  - unused_private_declaration
+  - vertical_parameter_alignment_on_call
+  - xct_specific_matcher
+  - yoda_condition
+
+excluded:
+  - Carthage
+  - External
+
+line_length:
+  ignores_function_declarations: true
+
+trailing_comma:
+  mandatory_comma: true
+
+trailing_whitespace:
+  ignores_comments: false
+  ignores_empty_lines: false
@@ -0,0 +1,30 @@
+language: objective-c
+
+os: osx
+osx_image: xcode11.4
+
+sudo: false # Enable container-based builds
+
+env:
+  matrix:
+    - SCHEME="SwiftGit2-OSX"
+    - SCHEME="SwiftGit2-iOS"
+
+matrix:
+  fast_finish: true
+
+before_install:
+  - gem update bundler # https://github.com/bundler/bundler/pull/4981
+  - gem install xcpretty
+  - gem install xcpretty-travis-formatter
+
+install: script/bootstrap
+
+script: script/cibuild
+
+branches:
+  only: # whitelist
+    - master
+
+notifications:
+  email: false
@@ -1 +0,0 @@
-github "antitypical/Result"
@@ -1,4 +1,4 @@
-github "jspahrsummers/xcconfigs" >= 0.7.2
-github "Quick/Quick" "155f858bce082373fc60d0c0a63415bf336c676b"
-github "Quick/Nimble" ~> 0.4.1
-github "modocache/Guanaco" "26b6ceff4b8912abd0dfc3a9eed0a46527e040e3"
+github "jspahrsummers/xcconfigs" ~> 1.1
+github "Quick/Quick" ~> 7.0
+github "Quick/Nimble" ~> 12.0
+github "ZipArchive/ZipArchive" ~> 2.0
@@ -1,5 +1,4 @@
-github "modocache/Guanaco" "26b6ceff4b8912abd0dfc3a9eed0a46527e040e3"
-github "Quick/Nimble" "v0.4.2"
-github "Quick/Quick" "155f858bce082373fc60d0c0a63415bf336c676b"
-github "antitypical/Result" "0.3"
-github "jspahrsummers/xcconfigs" "0.8"
+github "Quick/Nimble" "v12.3.0"
+github "Quick/Quick" "v7.3.0"
+github "ZipArchive/ZipArchive" "2.5.5"
+github "jspahrsummers/xcconfigs" "1.1"
@@ -1 +1 @@
-/usr/local/opt/openssl/lib/libcrypto.a
+/opt/homebrew/opt/openssl/lib/libcrypto.a
@@ -1 +1 @@
-/usr/local/opt/openssl/lib/libssl.a
+/opt/homebrew/opt/openssl/lib/libssl.a
@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2014-2016 SwiftGit2 contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
@@ -1,25 +1,35 @@
 # SwiftGit2
+[![Build Status](https://travis-ci.org/SwiftGit2/SwiftGit2.svg)](https://travis-ci.org/SwiftGit2/SwiftGit2)
+[![Carthage compatible](https://img.shields.io/badge/Carthage-compatible-4BC51D.svg?style=flat)](#carthage)
+[![GitHub release](https://img.shields.io/github/release/SwiftGit2/SwiftGit2.svg)](https://github.com/SwiftGit2/SwiftGit2/releases)
+![Swift 5.3.x](https://img.shields.io/badge/Swift-5.3.x-orange.svg)
+
 Swift bindings to [libgit2](https://github.com/libgit2/libgit2).

 ```swift
-let URL: NSURL = ...
-let repo = Repository.atURL(URL)
-if let repo = repo.value {
-    let latestCommit: Result<Commit, NSError> = repo
+let URL: URL = ...
+let result = Repository.at(URL)
+switch result {
+case let .success(repo):
+    let latestCommit = repo
        .HEAD()
-        .flatMap { repo.commitWithOID($0.oid) }
-    if let commit = latestCommit.value {
-        println("Latest Commit: \(commit.message) by \(commit.author.name)")
-    } else {
-        println("Could not get commit: \(latestCommit.error)")
+        .flatMap {
+            repo.commit($0.oid)
+        }
+
+    switch latestCommit {
+    case let .success(commit):
+        print("Latest Commit: \(commit.message) by \(commit.author.name)")
+
+    case let .failure(error):
+        print("Could not get commit: \(error)")
    }
-} else {
-    println("Could not open repository: \(repo.error)")
+
+case let .failure(error):
+    print("Could not open repository: \(error)")
 }
 ```

-SwiftGit2 requires Xcode 6.3 or later.
-
 ## Design
 SwiftGit2 uses value objects wherever possible. That means using Swift’s `struct`s and `enum`s without holding references to libgit2 objects. This has a number of advantages:

@@ -31,7 +41,21 @@ This vastly simplifies the design of long-lived applications, which are the most

 All methods for reading from or writing to a repository are on SwiftGit’s only `class`: `Repository`. This highlights the failability and mutation of these methods, while freeing up all other instances to be immutable `struct`s and `enum`s.

-## Importing SwiftGit2
+## Required Tools
+To build SwiftGit2, you'll need the following tools installed locally:
+
+* cmake
+* libssh2
+* libtool
+* autoconf
+* automake
+* pkg-config
+
+```
+brew install cmake libssh2 libtool autoconf automake pkg-config
+```
+
+## Adding SwiftGit2 to your Project
 The easiest way to add SwiftGit2 to your project is to use [Carthage](https://github.com/Carthage/Carthage). Simply add `github "SwiftGit2/SwiftGit2"` to your `Cartfile` and run `carthage update`.

 If you’d like, you can do things the ~~hard~~ old-fashioned way:
@@ -42,6 +66,13 @@ If you’d like, you can do things the ~~hard~~ old-fashioned way:
 4. On the “Build Phases” tab of your application target, add `SwiftGit2.framework` to the “Link Binary With Libraries” phase. SwiftGit2 must also be added to a “Copy Frameworks” build phase.
 5. **If you added SwiftGit2 to a project (not a workspace)**, you will also need to add the appropriate SwiftGit2 target to the “Target Dependencies” of your application.

+## Building SwiftGit2 Manually
+If you want to build a copy of SwiftGit2 without Carthage, possibly for development:
+
+1. Clone SwiftGit2
+2. Run `git submodule update --init --recursive` to clone the submodules
+3. Build in Xcode
+
 ## Contributions
 We :heart: to receive pull requests! GitHub makes it easy:

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0630"
+   LastUpgradeVersion = "1220"
   version = "1.3">
   <BuildAction
      parallelizeBuildables = "YES"
@@ -20,13 +20,36 @@
               ReferencedContainer = "container:SwiftGit2.xcodeproj">
            </BuildableReference>
         </BuildActionEntry>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "C9CE0DD21E0710BD0053205D"
+               BuildableName = "SwiftLint"
+               BlueprintName = "SwiftLint"
+               ReferencedContainer = "container:SwiftGit2.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
      </BuildActionEntries>
   </BuildAction>
   <TestAction
+      buildConfiguration = "Debug"
      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      shouldUseLaunchSchemeArgsEnv = "YES"
-      buildConfiguration = "Debug">
+      shouldUseLaunchSchemeArgsEnv = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "BEB31F221A0D6F7A00F525B9"
+            BuildableName = "SwiftGit2.framework"
+            BlueprintName = "SwiftGit2-OSX"
+            ReferencedContainer = "container:SwiftGit2.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
      <Testables>
         <TestableReference
            skipped = "NO">
@@ -41,13 +64,14 @@
      </Testables>
   </TestAction>
   <LaunchAction
+      buildConfiguration = "Debug"
      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
      launchStyle = "0"
      useCustomWorkingDirectory = "NO"
-      buildConfiguration = "Debug"
      ignoresPersistentStateOnLaunch = "NO"
      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
      allowLocationSimulation = "YES">
      <MacroExpansion>
         <BuildableReference
@@ -58,14 +82,12 @@
            ReferencedContainer = "container:SwiftGit2.xcodeproj">
         </BuildableReference>
      </MacroExpansion>
-      <AdditionalOptions>
-      </AdditionalOptions>
   </LaunchAction>
   <ProfileAction
+      buildConfiguration = "Release"
      shouldUseLaunchSchemeArgsEnv = "YES"
      savedToolIdentifier = ""
      useCustomWorkingDirectory = "NO"
-      buildConfiguration = "Release"
      debugDocumentVersioning = "YES">
      <MacroExpansion>
         <BuildableReference
@@ -0,0 +1,109 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "1220"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "621E66611C72958800A0F352"
+               BuildableName = "SwiftGit2.framework"
+               BlueprintName = "SwiftGit2-iOS"
+               ReferencedContainer = "container:SwiftGit2.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "C9CE0DD21E0710BD0053205D"
+               BuildableName = "SwiftLint"
+               BlueprintName = "SwiftLint"
+               ReferencedContainer = "container:SwiftGit2.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "621E66611C72958800A0F352"
+            BuildableName = "SwiftGit2.framework"
+            BlueprintName = "SwiftGit2-iOS"
+            ReferencedContainer = "container:SwiftGit2.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+      <Testables>
+         <TestableReference
+            skipped = "NO">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "621E66B61C72958D00A0F352"
+               BuildableName = "SwiftGit2-iOSTests.xctest"
+               BlueprintName = "SwiftGit2-iOSTests"
+               ReferencedContainer = "container:SwiftGit2.xcodeproj">
+            </BuildableReference>
+         </TestableReference>
+      </Testables>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "621E66611C72958800A0F352"
+            BuildableName = "SwiftGit2.framework"
+            BlueprintName = "SwiftGit2-iOS"
+            ReferencedContainer = "container:SwiftGit2.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "621E66611C72958800A0F352"
+            BuildableName = "SwiftGit2.framework"
+            BlueprintName = "SwiftGit2-iOS"
+            ReferencedContainer = "container:SwiftGit2.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>
@@ -4,9 +4,6 @@
   <FileRef
      location = "group:SwiftGit2.xcodeproj">
   </FileRef>
-   <FileRef
-      location = "group:Carthage/Checkouts/Result/Result.xcodeproj">
-   </FileRef>
   <FileRef
      location = "group:Carthage/Checkouts/Quick/Quick.xcodeproj">
   </FileRef>
@@ -14,6 +11,6 @@
      location = "group:Carthage/Checkouts/Nimble/Nimble.xcodeproj">
   </FileRef>
   <FileRef
-      location = "group:Carthage/Checkouts/Guanaco/Guanaco.xcodeproj">
+      location = "group:Carthage/Checkouts/ZipArchive/ZipArchive.xcodeproj">
   </FileRef>
 </Workspace>
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>
@@ -6,51 +6,53 @@
 //  Copyright (c) 2015 GitHub, Inc. All rights reserved.
 //

+import Clibgit2
+
 /// The flags defining how a checkout should be performed.
 /// More detail is available in the libgit2 documentation for `git_checkout_strategy_t`.
-public struct CheckoutStrategy : RawOptionSetType {
+public struct CheckoutStrategy: OptionSet {
 	private let value: UInt
-	
+
 	// MARK: - Initialization
-	
+
 	/// Create an instance initialized with `nil`.
 	public init(nilLiteral: ()) {
 		self.value = 0
 	}
-	
+
 	public init(rawValue value: UInt) {
 		self.value = value
 	}
-	
+
 	public init(_ strategy: git_checkout_strategy_t) {
-		self.value = UInt(strategy.value)
+		self.value = UInt(strategy.rawValue)
 	}
-	
+
 	public static var allZeros: CheckoutStrategy {
-		return self(rawValue: 0)
+		return self.init(rawValue: 0)
 	}
-	
+
 	// MARK: - Properties
-	
+
 	public var rawValue: UInt {
 		return value
 	}
-	
-	public var git_checkout_strategy: git_checkout_strategy_t {
+
+	public var gitCheckoutStrategy: git_checkout_strategy_t {
 		return git_checkout_strategy_t(UInt32(self.value))
 	}
-	
+
 	// MARK: - Values
-	
+
 	/// Default is a dry run, no actual updates.
 	public static let None = CheckoutStrategy(GIT_CHECKOUT_NONE)
-	
+
 	/// Allow safe updates that cannot overwrite uncommitted data.
 	public static let Safe = CheckoutStrategy(GIT_CHECKOUT_SAFE)
-	
+
 	/// Allow all updates to force working directory to look like index
 	public static let Force = CheckoutStrategy(GIT_CHECKOUT_FORCE)
-	
+
 	/// Allow checkout to recreate missing files.
 	public static let RecreateMissing = CheckoutStrategy(GIT_CHECKOUT_RECREATE_MISSING)

@@ -75,10 +77,10 @@ public struct CheckoutStrategy : RawOptionSetType {

 	/// Allow checkout to skip unmerged files
 	public static let SkipUnmerged = CheckoutStrategy(GIT_CHECKOUT_SKIP_UNMERGED)
-	
+
 	/// For unmerged files, checkout stage 2 from index
 	public static let UseOurs = CheckoutStrategy(GIT_CHECKOUT_USE_OURS)
-	
+
 	/// For unmerged files, checkout stage 3 from index
 	public static let UseTheirs = CheckoutStrategy(GIT_CHECKOUT_USE_THEIRS)

@@ -0,0 +1,70 @@
+//
+// Created by Arnon Keereena on 4/28/17.
+// Copyright (c) 2017 GitHub, Inc. All rights reserved.
+//
+
+import Foundation
+import Clibgit2
+
+public class CommitIterator: IteratorProtocol, Sequence {
+	public typealias Iterator = CommitIterator
+	public typealias Element = Result<Commit, NSError>
+	let repo: Repository
+	private var revisionWalker: OpaquePointer?
+
+	private enum Next {
+		case over
+		case okay
+		case error(NSError)
+
+		init(_ result: Int32, name: String) {
+			switch result {
+			case GIT_ITEROVER.rawValue:
+				self = .over
+			case GIT_OK.rawValue:
+				self = .okay
+			default:
+				self = .error(NSError(gitError: result, pointOfFailure: name))
+			}
+		}
+	}
+
+	init(repo: Repository, root: git_oid) {
+		self.repo = repo
+		setupRevisionWalker(root: root)
+	}
+
+	deinit {
+		git_revwalk_free(self.revisionWalker)
+	}
+
+	private func setupRevisionWalker(root: git_oid) {
+		var oid = root
+		git_revwalk_new(&revisionWalker, repo.pointer)
+		git_revwalk_sorting(revisionWalker, GIT_SORT_TOPOLOGICAL.rawValue)
+		git_revwalk_sorting(revisionWalker, GIT_SORT_TIME.rawValue)
+		git_revwalk_push(revisionWalker, &oid)
+	}
+
+	public func next() -> Element? {
+		var oid = git_oid()
+		let revwalkGitResult = git_revwalk_next(&oid, revisionWalker)
+		let nextResult = Next(revwalkGitResult, name: "git_revwalk_next")
+		switch nextResult {
+		case let .error(error):
+			return Result.failure(error)
+		case .over:
+			return nil
+		case .okay:
+			var unsafeCommit: OpaquePointer? = nil
+			let lookupGitResult = git_commit_lookup(&unsafeCommit, repo.pointer, &oid)
+			guard lookupGitResult == GIT_OK.rawValue,
+				let unwrapCommit = unsafeCommit else {
+					return Result.failure(NSError(gitError: lookupGitResult, pointOfFailure: "git_commit_lookup"))
+			}
+			let result: Element = Result.success(Commit(unwrapCommit))
+			git_commit_free(unsafeCommit)
+			return result
+		}
+	}
+}
@@ -0,0 +1,61 @@
+//
+//  Credentials.swift
+//  SwiftGit2
+//
+//  Created by Tom Booth on 29/02/2016.
+//  Copyright © 2016 GitHub, Inc. All rights reserved.
+//
+
+import Clibgit2
+
+private class Wrapper<T> {
+	let value: T
+
+	init(_ value: T) {
+		self.value = value
+	}
+}
+
+public enum Credentials {
+	case `default`
+	case sshAgent
+	case plaintext(username: String, password: String)
+	case sshMemory(username: String, publicKey: String, privateKey: String, passphrase: String)
+
+	internal static func fromPointer(_ pointer: UnsafeMutableRawPointer) -> Credentials {
+		return Unmanaged<Wrapper<Credentials>>.fromOpaque(UnsafeRawPointer(pointer)).takeRetainedValue().value
+	}
+
+	internal func toPointer() -> UnsafeMutableRawPointer {
+		return Unmanaged.passRetained(Wrapper(self)).toOpaque()
+	}
+}
+
+/// Handle the request of credentials, passing through to a wrapped block after converting the arguments.
+/// Converts the result to the correct error code required by libgit2 (0 = success, 1 = rejected setting creds,
+/// -1 = error)
+internal func credentialsCallback(
+	cred: UnsafeMutablePointer<UnsafeMutablePointer<git_cred>?>?,
+	url: UnsafePointer<CChar>?,
+	username: UnsafePointer<CChar>?,
+	_: UInt32,
+	payload: UnsafeMutableRawPointer? ) -> Int32 {
+
+	let result: Int32
+
+	// Find username_from_url
+	let name = username.map(String.init(cString:))
+
+	switch Credentials.fromPointer(payload!) {
+	case .default:
+		result = git_cred_default_new(cred)
+	case .sshAgent:
+		result = git_cred_ssh_key_from_agent(cred, name!)
+	case .plaintext(let username, let password):
+		result = git_cred_userpass_plaintext_new(cred, username, password)
+	case .sshMemory(let username, let publicKey, let privateKey, let passphrase):
+		result = git_cred_ssh_key_memory_new(cred, username, publicKey, privateKey, passphrase)
+	}
+
+	return (result != GIT_OK.rawValue) ? -1 : 0
+}
@@ -0,0 +1,111 @@
+//
+//  Diffs.swift
+//  SwiftGit2
+//
+//  Created by Jake Van Alstyne on 8/20/17.
+//  Copyright © 2017 GitHub, Inc. All rights reserved.
+//
+
+import Clibgit2
+
+public struct StatusEntry {
+	public var status: Diff.Status
+	public var headToIndex: Diff.Delta?
+	public var indexToWorkDir: Diff.Delta?
+
+	public init(from statusEntry: git_status_entry) {
+		self.status = Diff.Status(rawValue: statusEntry.status.rawValue)
+
+		if let htoi = statusEntry.head_to_index {
+			self.headToIndex = Diff.Delta(htoi.pointee)
+		}
+
+		if let itow = statusEntry.index_to_workdir {
+			self.indexToWorkDir = Diff.Delta(itow.pointee)
+		}
+	}
+}
+
+public struct Diff {
+
+	/// The set of deltas.
+	public var deltas = [Delta]()
+
+	public struct Delta {
+		public static let type = GIT_OBJECT_REF_DELTA
+
+		public var status: Status
+		public var flags: Flags
+		public var oldFile: File?
+		public var newFile: File?
+
+		public init(_ delta: git_diff_delta) {
+			self.status = Status(rawValue: UInt32(git_diff_status_char(delta.status)))
+			self.flags = Flags(rawValue: delta.flags)
+			self.oldFile = File(delta.old_file)
+			self.newFile = File(delta.new_file)
+		}
+	}
+
+	public struct File {
+		public var oid: OID
+		public var path: String
+		public var size: UInt64
+		public var flags: Flags
+
+		public init(_ diffFile: git_diff_file) {
+			self.oid = OID(diffFile.id)
+			let path = diffFile.path
+			self.path = path.map(String.init(cString:))!
+			self.size = diffFile.size
+			self.flags = Flags(rawValue: diffFile.flags)
+		}
+	}
+
+	public struct Status: OptionSet {
+		// This appears to be necessary due to bug in Swift
+		// https://bugs.swift.org/browse/SR-3003
+		public init(rawValue: UInt32) {
+			self.rawValue = rawValue
+		}
+		public let rawValue: UInt32
+
+		public static let current                = Status(rawValue: GIT_STATUS_CURRENT.rawValue)
+		public static let indexNew               = Status(rawValue: GIT_STATUS_INDEX_NEW.rawValue)
+		public static let indexModified          = Status(rawValue: GIT_STATUS_INDEX_MODIFIED.rawValue)
+		public static let indexDeleted           = Status(rawValue: GIT_STATUS_INDEX_DELETED.rawValue)
+		public static let indexRenamed           = Status(rawValue: GIT_STATUS_INDEX_RENAMED.rawValue)
+		public static let indexTypeChange        = Status(rawValue: GIT_STATUS_INDEX_TYPECHANGE.rawValue)
+		public static let workTreeNew            = Status(rawValue: GIT_STATUS_WT_NEW.rawValue)
+		public static let workTreeModified       = Status(rawValue: GIT_STATUS_WT_MODIFIED.rawValue)
+		public static let workTreeDeleted        = Status(rawValue: GIT_STATUS_WT_DELETED.rawValue)
+		public static let workTreeTypeChange     = Status(rawValue: GIT_STATUS_WT_TYPECHANGE.rawValue)
+		public static let workTreeRenamed        = Status(rawValue: GIT_STATUS_WT_RENAMED.rawValue)
+		public static let workTreeUnreadable     = Status(rawValue: GIT_STATUS_WT_UNREADABLE.rawValue)
+		public static let ignored                = Status(rawValue: GIT_STATUS_IGNORED.rawValue)
+		public static let conflicted             = Status(rawValue: GIT_STATUS_CONFLICTED.rawValue)
+	}
+
+	public struct Flags: OptionSet {
+		// This appears to be necessary due to bug in Swift
+		// https://bugs.swift.org/browse/SR-3003
+		public init(rawValue: UInt32) {
+			self.rawValue = rawValue
+		}
+		public let rawValue: UInt32
+
+		public static let binary     = Flags([])
+		public static let notBinary  = Flags(rawValue: 1 << 0)
+		public static let validId    = Flags(rawValue: 1 << 1)
+		public static let exists     = Flags(rawValue: 1 << 2)
+	}
+
+	/// Create an instance with a libgit2 `git_diff`.
+	public init(_ pointer: OpaquePointer) {
+		for i in 0..<git_diff_num_deltas(pointer) {
+			if let delta = git_diff_get_delta(pointer, i) {
+				deltas.append(Diff.Delta(delta.pointee))
+			}
+		}
+	}
+}
@@ -1,31 +1,33 @@
 import Foundation
+import Clibgit2

 public let libGit2ErrorDomain = "org.libgit2.libgit2"

-/// Returns an NSError with an error domain and message for libgit2 errors.
-///
-/// :param: errorCode An error code returned by a libgit2 function.
-/// :param: libGit2PointOfFailure The name of the libgit2 function that produced the
-///         error code.
-/// :returns: An NSError with a libgit2 error domain, code, and message.
-internal func libGit2Error(errorCode: Int32, libGit2PointOfFailure: String? = nil) -> NSError {
-	let code = Int(errorCode)
-	var userInfo: [String: String] = [:]
+internal extension NSError {
+	/// Returns an NSError with an error domain and message for libgit2 errors.
+	///
+	/// :param: errorCode An error code returned by a libgit2 function.
+	/// :param: libGit2PointOfFailure The name of the libgit2 function that produced the
+	///         error code.
+	/// :returns: An NSError with a libgit2 error domain, code, and message.
+	convenience init(gitError errorCode: Int32, pointOfFailure: String? = nil) {
+		let code = Int(errorCode)
+		var userInfo: [String: String] = [:]

-	if let message = errorMessage(errorCode) {
-		userInfo[NSLocalizedDescriptionKey] = message
-	} else {
-		userInfo[NSLocalizedDescriptionKey] = "Unknown libgit2 error."
+		if let message = errorMessage(errorCode) {
+			userInfo[NSLocalizedDescriptionKey] = message
+		} else {
+			userInfo[NSLocalizedDescriptionKey] = "Unknown libgit2 error."
+		}
+
+		if let pointOfFailure = pointOfFailure {
+			userInfo[NSLocalizedFailureReasonErrorKey] = "\(pointOfFailure) failed."
+		}
+
+		self.init(domain: libGit2ErrorDomain, code: code, userInfo: userInfo)
 	}
-
-	if let pointOfFailure = libGit2PointOfFailure {
-		userInfo[NSLocalizedFailureReasonErrorKey] = "\(pointOfFailure) failed."
-	}
-
-	return NSError(domain: libGit2ErrorDomain, code: code, userInfo: userInfo)
 }

-
 /// Returns the libgit2 error message for the given error code.
 ///
 /// The error message represents the last error message generated by
@@ -36,12 +38,12 @@ internal func libGit2Error(errorCode: Int32, libGit2PointOfFailure: String? = ni
 ///           or errno has been set by the system, this function returns the
 ///           corresponding string representation of that error. Otherwise, it returns
 ///           nil.
-private func errorMessage(errorCode: Int32) -> String? {
+private func errorMessage(_ errorCode: Int32) -> String? {
 	let last = giterr_last()
-	if last != nil {
-		return String.fromCString(last.memory.message)
-	} else if UInt32(errorCode) == GITERR_OS.value {
-		return String.fromCString(strerror(errno))
+	if let lastErrorPointer = last {
+		return String(validatingUTF8: lastErrorPointer.pointee.message)
+	} else if UInt32(errorCode) == GIT_ERROR_OS.rawValue {
+		return String(validatingUTF8: strerror(errno))
 	} else {
 		return nil
 	}
@@ -7,7 +7,7 @@
 	<key>CFBundleExecutable</key>
 	<string>$(EXECUTABLE_NAME)</string>
 	<key>CFBundleIdentifier</key>
-	<string>org.libgit2.$(PRODUCT_NAME:rfc1034identifier)</string>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
 	<key>CFBundleInfoDictionaryVersion</key>
 	<string>6.0</string>
 	<key>CFBundleName</key>
@@ -6,20 +6,17 @@
 //  Copyright (c) 2015 GitHub, Inc. All rights reserved.
 //

-func == (lhs: git_otype, rhs: git_otype) -> Bool {
-	return lhs.value == rhs.value
-}
+import Clibgit2

 extension git_strarray {
-	func filter(f: (String) -> Bool) -> [String] {
-		return map { $0 }.filter(f)
+	func filter(_ isIncluded: (String) -> Bool) -> [String] {
+		return map { $0 }.filter(isIncluded)
 	}
-	
-	func map<T>(f: (String) -> T) -> [T] {
-		return Swift.map(0..<self.count) {
-			let string = String.fromCString(self.strings[Int($0)])!
-			return f(string)
+
+	func map<T>(_ transform: (String) -> T) -> [T] {
+		return (0..<self.count).map {
+			let string = String(validatingUTF8: self.strings[$0]!)!
+			return transform(string)
 		}
 	}
 }
-
@@ -6,76 +6,65 @@
 //  Copyright (c) 2014 GitHub, Inc. All rights reserved.
 //

-import Foundation
-import Result
+import Clibgit2

 /// An identifier for a Git object.
 public struct OID {
-	
+
 	// MARK: - Initializers
-	
+
 	/// Create an instance from a hex formatted string.
 	///
 	/// string - A 40-byte hex formatted string.
 	public init?(string: String) {
 		// libgit2 doesn't enforce a maximum length
-		if (string.lengthOfBytesUsingEncoding(NSASCIIStringEncoding) > 40) {
+		if string.lengthOfBytes(using: String.Encoding.ascii) > 40 {
 			return nil
 		}
-		
-		let pointer = UnsafeMutablePointer<git_oid>.alloc(1)
+
+		let pointer = UnsafeMutablePointer<git_oid>.allocate(capacity: 1)
 		let result = git_oid_fromstr(pointer, string)
-		
-		if result < GIT_OK.value {
-			pointer.dealloc(1)
-			return nil;
+
+		if result < GIT_OK.rawValue {
+			pointer.deallocate()
+			return nil
 		}
-		
-		oid = pointer.memory;
-		pointer.dealloc(1)
+
+		oid = pointer.pointee
+		pointer.deallocate()
 	}
-	
+
 	/// Create an instance from a libgit2 `git_oid`.
 	public init(_ oid: git_oid) {
 		self.oid = oid
 	}
-	
+
 	// MARK: - Properties
-	
+
 	public let oid: git_oid
 }

-extension OID: Printable {
+extension OID: CustomStringConvertible {
 	public var description: String {
 		let length = Int(GIT_OID_RAWSZ) * 2
-		let string = UnsafeMutablePointer<Int8>.alloc(length)
+		let string = UnsafeMutablePointer<Int8>.allocate(capacity: length)
 		var oid = self.oid
 		git_oid_fmt(string, &oid)
-		
-		return String(bytesNoCopy: string, length: length, encoding: NSASCIIStringEncoding, freeWhenDone: true)!
+
+		return String(bytesNoCopy: string, length: length, encoding: .ascii, freeWhenDone: true)!
 	}
 }

 extension OID: Hashable {
-	public var hashValue: Int {
-		let bytes = [
-			self.oid.id.0,
-			self.oid.id.1,
-			self.oid.id.2,
-			self.oid.id.3,
-			self.oid.id.4,
-			self.oid.id.5,
-			self.oid.id.6,
-			self.oid.id.7
-		]
-		return reduce(bytes, 0, { (hash, byte) in
-			return Int(hash << 8) | Int(byte)
-		})
+	public func hash(into hasher: inout Hasher) {
+		withUnsafeBytes(of: oid.id) {
+			hasher.combine(bytes: $0)
+		}
+	}
+
+	public static func == (lhs: OID, rhs: OID) -> Bool {
+		var left = lhs.oid
+		var right = rhs.oid
+		return git_oid_cmp(&left, &right) == 0
 	}
 }
-
-public func == (lhs: OID, rhs: OID) -> Bool {
-	var left = lhs.oid
-	var right = rhs.oid
-	return git_oid_cmp(&left, &right) == 0
-}
@@ -7,122 +7,140 @@
 //

 import Foundation
+import Clibgit2

 /// A git object.
 public protocol ObjectType {
-	static var type: git_otype { get }
-	
+	static var type: git_object_t { get }
+
 	/// The OID of the object.
 	var oid: OID { get }
-	
+
 	/// Create an instance with the underlying libgit2 type.
-	init(_ pointer: COpaquePointer)
+	init(_ pointer: OpaquePointer)
 }

-public func == <O: ObjectType>(lhs: O, rhs: O) -> Bool {
-	return lhs.oid == rhs.oid
+public extension ObjectType {
+	static func == (lhs: Self, rhs: Self) -> Bool {
+		return lhs.oid == rhs.oid
+	}
+
+	func hash(into hasher: inout Hasher) {
+		hasher.combine(oid)
+	}
 }

 public struct Signature {
 	/// The name of the person.
 	public let name: String
-	
+
 	/// The email of the person.
 	public let email: String
-	
+
 	/// The time when the action happened.
-	public let time: NSDate
-	
+	public let time: Date
+
 	/// The time zone that `time` should be interpreted relative to.
-	public let timeZone: NSTimeZone
-	
+	public let timeZone: TimeZone
+
+	/// Create an instance with custom name, email, dates, etc.
+	public init(name: String, email: String, time: Date = Date(), timeZone: TimeZone = TimeZone.autoupdatingCurrent) {
+		self.name = name
+		self.email = email
+		self.time = time
+		self.timeZone = timeZone
+	}
+
 	/// Create an instance with a libgit2 `git_signature`.
 	public init(_ signature: git_signature) {
-		name = String.fromCString(signature.name)!
-		email = String.fromCString(signature.email)!
-		time = NSDate(timeIntervalSince1970: NSTimeInterval(signature.when.time))
-		timeZone = NSTimeZone(forSecondsFromGMT: NSInteger(60 * signature.when.offset))
+		name = String(validatingUTF8: signature.name)!
+		email = String(validatingUTF8: signature.email)!
+		time = Date(timeIntervalSince1970: TimeInterval(signature.when.time))
+		timeZone = TimeZone(secondsFromGMT: 60 * Int(signature.when.offset))!
+	}
+
+	/// Return an unsafe pointer to the `git_signature` struct.
+	/// Caller is responsible for freeing it with `git_signature_free`.
+	func makeUnsafeSignature() -> Result<UnsafeMutablePointer<git_signature>, NSError> {
+		var signature: UnsafeMutablePointer<git_signature>? = nil
+		let time = git_time_t(self.time.timeIntervalSince1970)	// Unix epoch time
+		let offset = Int32(timeZone.secondsFromGMT(for: self.time) / 60)
+		let signatureResult = git_signature_new(&signature, name, email, time, offset)
+		guard signatureResult == GIT_OK.rawValue, let signatureUnwrap = signature else {
+			let err = NSError(gitError: signatureResult, pointOfFailure: "git_signature_new")
+			return .failure(err)
+		}
+		return .success(signatureUnwrap)
 	}
 }

 extension Signature: Hashable {
-	public var hashValue: Int {
-		return name.hashValue ^ email.hashValue ^ time.timeIntervalSince1970.hashValue
+	public func hash(into hasher: inout Hasher) {
+		hasher.combine(name)
+		hasher.combine(email)
+		hasher.combine(time)
 	}
 }

-public func == (lhs: Signature, rhs: Signature) -> Bool {
-	return lhs.name == rhs.name
-		&& lhs.email == rhs.email
-		&& lhs.time == rhs.time
-		&& lhs.timeZone.secondsFromGMT == rhs.timeZone.secondsFromGMT
-}
-
 /// A git commit.
-public struct Commit: ObjectType {
-	public static let type = GIT_OBJ_COMMIT
-	
+public struct Commit: ObjectType, Hashable {
+	public static let type = GIT_OBJECT_COMMIT
+
 	/// The OID of the commit.
 	public let oid: OID
-	
+
 	/// The OID of the commit's tree.
 	public let tree: PointerTo<Tree>
-	
+
 	/// The OIDs of the commit's parents.
 	public let parents: [PointerTo<Commit>]
-	
+
 	/// The author of the commit.
 	public let author: Signature
-	
+
 	/// The committer of the commit.
 	public let committer: Signature
-	
+
 	/// The full message of the commit.
 	public let message: String
-	
-	/// Create an instance with a libgit2 `git_commit` object.
-	public init(_ pointer: COpaquePointer) {
-		oid = OID(git_object_id(pointer).memory)
-		message = String.fromCString(git_commit_message(pointer))!
-		author = Signature(git_commit_author(pointer).memory)
-		committer = Signature(git_commit_committer(pointer).memory)
-		tree = PointerTo(OID(git_commit_tree_id(pointer).memory))
-		
-		self.parents = map(0..<git_commit_parentcount(pointer)) {
-			return PointerTo(OID(git_commit_parent_id(pointer, $0).memory))
-		}
-	}
-}

-extension Commit: Hashable {
-	public var hashValue: Int {
-		return self.oid.hashValue
+	/// Create an instance with a libgit2 `git_commit` object.
+	public init(_ pointer: OpaquePointer) {
+		oid = OID(git_object_id(pointer).pointee)
+		message = String(validatingUTF8: git_commit_message(pointer))!
+		author = Signature(git_commit_author(pointer).pointee)
+		committer = Signature(git_commit_committer(pointer).pointee)
+		tree = PointerTo(OID(git_commit_tree_id(pointer).pointee))
+
+		self.parents = (0..<git_commit_parentcount(pointer)).map {
+			return PointerTo(OID(git_commit_parent_id(pointer, $0).pointee))
+		}
 	}
 }

 /// A git tree.
-public struct Tree: ObjectType {
-	public static let type = GIT_OBJ_TREE
-	
+public struct Tree: ObjectType, Hashable {
+	public static let type = GIT_OBJECT_TREE
+
 	/// An entry in a `Tree`.
-	public struct Entry {
+	public struct Entry: Hashable {
 		/// The entry's UNIX file attributes.
 		public let attributes: Int32
-		
+
 		/// The object pointed to by the entry.
 		public let object: Pointer
-		
+
 		/// The file name of the entry.
 		public let name: String
-		
+
 		/// Create an instance with a libgit2 `git_tree_entry`.
-		public init(_ pointer: COpaquePointer) {
-			let oid = OID(git_tree_entry_id(pointer).memory)
-			attributes = Int32(git_tree_entry_filemode(pointer).value)
+		public init(_ pointer: OpaquePointer) {
+			let oid = OID(git_tree_entry_id(pointer).pointee)
+			attributes = Int32(git_tree_entry_filemode(pointer).rawValue)
 			object = Pointer(oid: oid, type: git_tree_entry_type(pointer))!
-			name = String.fromCString(git_tree_entry_name(pointer))!
+			name = String(validatingUTF8: git_tree_entry_name(pointer))!
 		}
-		
+
 		/// Create an instance with the individual values.
 		public init(attributes: Int32, object: Pointer, name: String) {
 			self.attributes = attributes
@@ -133,105 +151,74 @@ public struct Tree: ObjectType {

 	/// The OID of the tree.
 	public let oid: OID
-	
+
 	/// The entries in the tree.
 	public let entries: [String: Entry]
-	
+
 	/// Create an instance with a libgit2 `git_tree`.
-	public init(_ pointer: COpaquePointer) {
-		oid = OID(git_object_id(pointer).memory)
-		
+	public init(_ pointer: OpaquePointer) {
+		oid = OID(git_object_id(pointer).pointee)
+
 		var entries: [String: Entry] = [:]
 		for idx in 0..<git_tree_entrycount(pointer) {
-			let entry = Entry(git_tree_entry_byindex(pointer, idx))
+			let entry = Entry(git_tree_entry_byindex(pointer, idx)!)
 			entries[entry.name] = entry
 		}
 		self.entries = entries
 	}
 }

-extension Tree.Entry: Hashable {
-	public var hashValue: Int {
-		return Int(attributes) ^ object.hashValue ^ name.hashValue
-	}
-}
-
-extension Tree.Entry: Printable {
+extension Tree.Entry: CustomStringConvertible {
 	public var description: String {
 		return "\(attributes) \(object) \(name)"
 	}
 }

-public func == (lhs: Tree.Entry, rhs: Tree.Entry) -> Bool {
-	return lhs.attributes == rhs.attributes
-		&& lhs.object == rhs.object
-		&& lhs.name == rhs.name
-}
-
-extension Tree: Hashable {
-	public var hashValue: Int {
-		return oid.hashValue
-	}
-}
-
 /// A git blob.
-public struct Blob: ObjectType {
-	public static let type = GIT_OBJ_BLOB
-	
+public struct Blob: ObjectType, Hashable {
+	public static let type = GIT_OBJECT_BLOB
+
 	/// The OID of the blob.
 	public let oid: OID
-	
-	/// The contents of the blob.
-	public let data: NSData
-	
-	/// Create an instance with a libgit2 `git_blob`.
-	public init(_ pointer: COpaquePointer) {
-		oid = OID(git_object_id(pointer).memory)
-		
-		// Swift doesn't get the types right without `Int(Int64(...))` :(
-		let length = Int(Int64(git_blob_rawsize(pointer).value))
-		data = NSData(bytes: git_blob_rawcontent(pointer), length: length)
-	}
-}

-extension Blob: Hashable {
-	public var hashValue: Int {
-		return oid.hashValue
+	/// The contents of the blob.
+	public let data: Data
+
+	/// Create an instance with a libgit2 `git_blob`.
+	public init(_ pointer: OpaquePointer) {
+		oid = OID(git_object_id(pointer).pointee)
+
+		let length = Int(git_blob_rawsize(pointer))
+		data = Data(bytes: git_blob_rawcontent(pointer), count: length)
 	}
 }

 /// An annotated git tag.
-public struct Tag: ObjectType {
-	public static let type = GIT_OBJ_TAG
-	
+public struct Tag: ObjectType, Hashable {
+	public static let type = GIT_OBJECT_TAG
+
 	/// The OID of the tag.
 	public let oid: OID
-	
+
 	/// The tagged object.
 	public let target: Pointer
-	
+
 	/// The name of the tag.
 	public let name: String
-	
+
 	/// The tagger (author) of the tag.
 	public let tagger: Signature
-	
+
 	/// The message of the tag.
 	public let message: String
-	
-	/// Create an instance with a libgit2 `git_tag`.
-	public init(_ pointer: COpaquePointer) {
-		oid = OID(git_object_id(pointer).memory)
-		let targetOID = OID(git_tag_target_id(pointer).memory)
-		target = Pointer(oid: targetOID, type: git_tag_target_type(pointer))!
-		name = String.fromCString(git_tag_name(pointer))!
-		tagger = Signature(git_tag_tagger(pointer).memory)
-		message = String.fromCString(git_tag_message(pointer))!
-	}
-}

-extension Tag: Hashable {
-	public var hashValue: Int {
-		return oid.hashValue
+	/// Create an instance with a libgit2 `git_tag`.
+	public init(_ pointer: OpaquePointer) {
+		oid = OID(git_object_id(pointer).pointee)
+		let targetOID = OID(git_tag_target_id(pointer).pointee)
+		target = Pointer(oid: targetOID, type: git_tag_target_type(pointer))!
+		name = String(validatingUTF8: git_tag_name(pointer))!
+		tagger = Signature(git_tag_tagger(pointer).pointee)
+		message = String(validatingUTF8: git_tag_message(pointer))!
 	}
 }
@@ -6,89 +6,88 @@
 //  Copyright (c) 2014 GitHub, Inc. All rights reserved.
 //

-import Foundation
-
-import Foundation
+import Clibgit2

 /// A pointer to a git object.
-public protocol PointerType: Equatable, Hashable {
+public protocol PointerType: Hashable {
 	/// The OID of the referenced object.
 	var oid: OID { get }
-	
-	/// The libgit2 `git_otype` of the referenced object.
-	var type: git_otype { get }
+
+	/// The libgit2 `git_object_t` of the referenced object.
+	var type: git_object_t { get }
 }

-public func == <P: PointerType>(lhs: P, rhs: P) -> Bool {
-	return lhs.oid == rhs.oid && lhs.type.value == rhs.type.value
+public extension PointerType {
+	static func == (lhs: Self, rhs: Self) -> Bool {
+		return lhs.oid == rhs.oid
+			&& lhs.type == rhs.type
+	}
+
+	func hash(into hasher: inout Hasher) {
+		hasher.combine(oid)
+	}
 }

 /// A pointer to a git object.
 public enum Pointer: PointerType {
-	case Commit(OID)
-	case Tree(OID)
-	case Blob(OID)
-	case Tag(OID)
-	
+	case commit(OID)
+	case tree(OID)
+	case blob(OID)
+	case tag(OID)
+
 	public var oid: OID {
 		switch self {
-		case let Commit(oid):
+		case let .commit(oid):
 			return oid
-		case let Tree(oid):
+		case let .tree(oid):
 			return oid
-		case let Blob(oid):
+		case let .blob(oid):
 			return oid
-		case let Tag(oid):
+		case let .tag(oid):
 			return oid
 		}
 	}
-	
-	public var type: git_otype {
+
+	public var type: git_object_t {
 		switch self {
-		case let Commit(oid):
-			return GIT_OBJ_COMMIT
-		case let Tree(oid):
-			return GIT_OBJ_TREE
-		case let Blob(oid):
-			return GIT_OBJ_BLOB
-		case let Tag(oid):
-			return GIT_OBJ_TAG
+		case .commit:
+			return GIT_OBJECT_COMMIT
+		case .tree:
+			return GIT_OBJECT_TREE
+		case .blob:
+			return GIT_OBJECT_BLOB
+		case .tag:
+			return GIT_OBJECT_TAG
 		}
 	}
-	
-	/// Create an instance with an OID and a libgit2 `git_otype`.
-	init?(oid: OID, type: git_otype) {
-		switch type.value {
-		case GIT_OBJ_COMMIT.value:
-			self = Commit(oid)
-		case GIT_OBJ_TREE.value:
-			self = Tree(oid)
-		case GIT_OBJ_BLOB.value:
-			self = Blob(oid)
-		case GIT_OBJ_TAG.value:
-			self = Tag(oid)
+
+	/// Create an instance with an OID and a libgit2 `git_object_t`.
+	init?(oid: OID, type: git_object_t) {
+		switch type {
+		case GIT_OBJECT_COMMIT:
+			self = .commit(oid)
+		case GIT_OBJECT_TREE:
+			self = .tree(oid)
+		case GIT_OBJECT_BLOB:
+			self = .blob(oid)
+		case GIT_OBJECT_TAG:
+			self = .tag(oid)
 		default:
 			return nil
 		}
 	}
 }

-extension Pointer: Hashable {
-	public var hashValue: Int {
-		return oid.hashValue
-	}
-}
-
-extension Pointer: Printable {
+extension Pointer: CustomStringConvertible {
 	public var description: String {
 		switch self {
-		case Commit:
+		case .commit:
 			return "commit(\(oid))"
-		case Tree:
+		case .tree:
 			return "tree(\(oid))"
-		case Blob:
+		case .blob:
 			return "blob(\(oid))"
-		case Tag:
+		case .tag:
 			return "tag(\(oid))"
 		}
 	}
@@ -96,8 +95,8 @@ extension Pointer: Printable {

 public struct PointerTo<T: ObjectType>: PointerType {
 	public let oid: OID
-	
-	public var type: git_otype {
+
+	public var type: git_object_t {
 		return T.type
 	}

@@ -105,9 +104,3 @@ public struct PointerTo<T: ObjectType>: PointerType {
 		self.oid = oid
 	}
 }
-
-extension PointerTo: Hashable {
-	public var hashValue: Int {
-		return oid.hashValue
-	}
-}
@@ -6,25 +6,34 @@
 //  Copyright (c) 2015 GitHub, Inc. All rights reserved.
 //

+import Clibgit2
+
 /// A reference to a git object.
 public protocol ReferenceType {
 	/// The full name of the reference (e.g., `refs/heads/master`).
 	var longName: String { get }
-	
+
 	/// The short human-readable name of the reference if one exists (e.g., `master`).
 	var shortName: String? { get }
-	
+
 	/// The OID of the referenced object.
 	var oid: OID { get }
 }

-public func ==<T: ReferenceType>(lhs: T, rhs: T) -> Bool {
-	return lhs.longName == rhs.longName
-		&& lhs.oid == rhs.oid
+public extension ReferenceType {
+	static func == (lhs: Self, rhs: Self) -> Bool {
+		return lhs.longName == rhs.longName
+			&& lhs.oid == rhs.oid
+	}
+
+	func hash(into hasher: inout Hasher) {
+		hasher.combine(longName)
+		hasher.combine(oid)
+	}
 }

 /// Create a Reference, Branch, or TagReference from a libgit2 `git_reference`.
-internal func referenceWithLibGit2Reference(pointer: COpaquePointer) -> ReferenceType {
+internal func referenceWithLibGit2Reference(_ pointer: OpaquePointer) -> ReferenceType {
 	if git_reference_is_branch(pointer) != 0 || git_reference_is_remote(pointer) != 0 {
 		return Branch(pointer)!
 	} else if git_reference_is_tag(pointer) != 0 {
@@ -35,167 +44,146 @@ internal func referenceWithLibGit2Reference(pointer: COpaquePointer) -> Referenc
 }

 /// A generic reference to a git object.
-public struct Reference: ReferenceType {
+public struct Reference: ReferenceType, Hashable {
 	/// The full name of the reference (e.g., `refs/heads/master`).
 	public let longName: String
-	
+
 	/// The short human-readable name of the reference if one exists (e.g., `master`).
 	public let shortName: String?
-	
+
 	/// The OID of the referenced object.
 	public let oid: OID
-	
-	/// Create an instance with a libgit2 `git_reference` object.
-	public init(_ pointer: COpaquePointer) {
-		let shorthand = String.fromCString(git_reference_shorthand(pointer))!
-		longName = String.fromCString(git_reference_name(pointer))!
-		shortName = (shorthand == longName ? nil : shorthand)
-		oid = OID(git_reference_target(pointer).memory)
-	}
-}

-extension Reference: Hashable {
-	public var hashValue: Int {
-		return longName.hashValue ^ oid.hashValue
+	/// Create an instance with a libgit2 `git_reference` object.
+	public init(_ pointer: OpaquePointer) {
+		let shorthand = String(validatingUTF8: git_reference_shorthand(pointer))!
+		longName = String(validatingUTF8: git_reference_name(pointer))!
+		shortName = (shorthand == longName ? nil : shorthand)
+		oid = OID(git_reference_target(pointer).pointee)
 	}
 }

 /// A git branch.
-public struct Branch: ReferenceType {
+public struct Branch: ReferenceType, Hashable {
 	/// The full name of the reference (e.g., `refs/heads/master`).
 	public let longName: String
-	
+
 	/// The short human-readable name of the branch (e.g., `master`).
 	public let name: String
-	
+
 	/// A pointer to the referenced commit.
 	public let commit: PointerTo<Commit>
-	
+
 	// MARK: Derived Properties
-	
+
 	/// The short human-readable name of the branch (e.g., `master`).
 	///
 	/// This is the same as `name`, but is declared with an Optional type to adhere to
 	/// `ReferenceType`.
 	public var shortName: String? { return name }
-	
+
 	/// The OID of the referenced object.
 	///
 	/// This is the same as `commit.oid`, but is declared here to adhere to `ReferenceType`.
 	public var oid: OID { return commit.oid }
-	
+
 	/// Whether the branch is a local branch.
 	public var isLocal: Bool { return longName.hasPrefix("refs/heads/") }
-	
+
 	/// Whether the branch is a remote branch.
 	public var isRemote: Bool { return longName.hasPrefix("refs/remotes/") }
-	
+
 	/// Create an instance with a libgit2 `git_reference` object.
 	///
 	/// Returns `nil` if the pointer isn't a branch.
-	public init?(_ pointer: COpaquePointer) {
-		let namePointer = UnsafeMutablePointer<UnsafePointer<Int8>>.alloc(1)
-		let success = git_branch_name(namePointer, pointer)
-		if success != GIT_OK.value {
-			namePointer.dealloc(1)
+	public init?(_ pointer: OpaquePointer) {
+		var namePointer: UnsafePointer<Int8>? = nil
+		let success = git_branch_name(&namePointer, pointer)
+		guard success == GIT_OK.rawValue else {
 			return nil
 		}
-		name = String.fromCString(namePointer.memory)!
-		namePointer.dealloc(1)
-		
-		longName = String.fromCString(git_reference_name(pointer))!
-		
+		name = String(validatingUTF8: namePointer!)!
+
+		longName = String(validatingUTF8: git_reference_name(pointer))!
+
 		var oid: OID
-		if git_reference_type(pointer).value == GIT_REF_SYMBOLIC.value {
-			var resolved: COpaquePointer = nil
+		if git_reference_type(pointer).rawValue == GIT_REFERENCE_SYMBOLIC.rawValue {
+			var resolved: OpaquePointer? = nil
 			let success = git_reference_resolve(&resolved, pointer)
-			if success != GIT_OK.value {
+			guard success == GIT_OK.rawValue else {
 				return nil
 			}
-			oid = OID(git_reference_target(resolved).memory)
+			oid = OID(git_reference_target(resolved).pointee)
 			git_reference_free(resolved)
 		} else {
-			oid = OID(git_reference_target(pointer).memory)
+			oid = OID(git_reference_target(pointer).pointee)
 		}
 		commit = PointerTo<Commit>(oid)
 	}
 }

-extension Branch: Hashable {
-	public var hashValue: Int {
-		return longName.hashValue ^ oid.hashValue
-	}
-}
-
 /// A git tag reference, which can be either a lightweight tag or a Tag object.
-public enum TagReference: ReferenceType {
+public enum TagReference: ReferenceType, Hashable {
 	/// A lightweight tag, which is just a name and an OID.
-	case Lightweight(String, OID)
-	
+	case lightweight(String, OID)
+
 	/// An annotated tag, which points to a Tag object.
-	case Annotated(String, Tag)
-	
+	case annotated(String, Tag)
+
 	/// The full name of the reference (e.g., `refs/tags/my-tag`).
 	public var longName: String {
 		switch self {
-		case let .Lightweight(name, _):
+		case let .lightweight(name, _):
 			return name
-		case let .Annotated(name, _):
+		case let .annotated(name, _):
 			return name
 		}
 	}
-	
+
 	/// The short human-readable name of the branch (e.g., `master`).
 	public var name: String {
-		return longName.substringFromIndex("refs/tags/".endIndex)
+		return String(longName["refs/tags/".endIndex...])
 	}
-	
+
 	/// The OID of the target object.
 	///
 	/// If this is an annotated tag, the OID will be the tag's target.
 	public var oid: OID {
 		switch self {
-		case let .Lightweight(_, oid):
+		case let .lightweight(_, oid):
 			return oid
-		case let .Annotated(_, tag):
+		case let .annotated(_, tag):
 			return tag.target.oid
 		}
 	}
-	
+
 	// MARK: Derived Properties
-	
+
 	/// The short human-readable name of the branch (e.g., `master`).
 	///
 	/// This is the same as `name`, but is declared with an Optional type to adhere to
 	/// `ReferenceType`.
 	public var shortName: String? { return name }
-	
+
 	/// Create an instance with a libgit2 `git_reference` object.
 	///
 	/// Returns `nil` if the pointer isn't a branch.
-	public init?(_ pointer: COpaquePointer) {
+	public init?(_ pointer: OpaquePointer) {
 		if git_reference_is_tag(pointer) == 0 {
-			return nil;
+			return nil
 		}
-		
-		let name = String.fromCString(git_reference_name(pointer))!
+
+		let name = String(validatingUTF8: git_reference_name(pointer))!
 		let repo = git_reference_owner(pointer)
-		var oid = git_reference_target(pointer).memory
-		
-		var pointer: COpaquePointer = nil
-		let result = git_object_lookup(&pointer, repo, &oid, GIT_OBJ_TAG)
-		if result == GIT_OK.value {
-			self = .Annotated(name, Tag(pointer))
+		var oid = git_reference_target(pointer).pointee
+
+		var pointer: OpaquePointer? = nil
+		let result = git_object_lookup(&pointer, repo, &oid, GIT_OBJECT_TAG)
+		if result == GIT_OK.rawValue {
+			self = .annotated(name, Tag(pointer!))
 		} else {
-			self = .Lightweight(name, OID(oid))
+			self = .lightweight(name, OID(oid))
 		}
 		git_object_free(pointer)
 	}
 }
-
-extension TagReference: Hashable {
-	public var hashValue: Int {
-		return longName.hashValue ^ oid.hashValue
-	}
-}
-
@@ -6,29 +6,21 @@
 //  Copyright (c) 2015 GitHub, Inc. All rights reserved.
 //

+import Clibgit2
+
 /// A remote in a git repository.
-public struct Remote {
+public struct Remote: Hashable {
 	/// The name of the remote.
 	public let name: String
-	
+
 	/// The URL of the remote.
 	///
 	/// This may be an SSH URL, which isn't representable using `NSURL`.
 	public let URL: String
-	
+
 	/// Create an instance with a libgit2 `git_remote`.
-	public init(_ pointer: COpaquePointer) {
-		name = String.fromCString(git_remote_name(pointer))!
-		URL = String.fromCString(git_remote_url(pointer))!
+	public init(_ pointer: OpaquePointer) {
+		name = String(validatingUTF8: git_remote_name(pointer))!
+		URL = String(validatingUTF8: git_remote_url(pointer))!
 	}
 }
-
-extension Remote: Hashable {
-	public var hashValue: Int {
-		return name.hashValue ^ URL.hashValue
-	}
-}
-
-public func == (lhs: Remote, rhs: Remote) -> Bool {
-	return lhs.name == rhs.name && lhs.URL == rhs.URL
-}
@@ -0,0 +1,63 @@
+//
+//  Copyright © 2020 GitHub, Inc. All rights reserved.
+//
+
+import Clibgit2
+import Foundation
+
+public struct StatusOptions: OptionSet {
+	public let rawValue: UInt32
+
+	public init(rawValue: UInt32) {
+		self.rawValue = rawValue
+	}
+
+	public static let includeUntracked = StatusOptions(
+		rawValue: GIT_STATUS_OPT_INCLUDE_UNTRACKED.rawValue
+	)
+	public static let includeIgnored = StatusOptions(
+		rawValue: GIT_STATUS_OPT_INCLUDE_IGNORED.rawValue
+	)
+	public static let includeUnmodified = StatusOptions(
+		rawValue: GIT_STATUS_OPT_INCLUDE_UNMODIFIED.rawValue
+	)
+	public static let excludeSubmodules = StatusOptions(
+		rawValue: GIT_STATUS_OPT_EXCLUDE_SUBMODULES.rawValue
+	)
+	public static let recurseUntrackedDirs = StatusOptions(
+		rawValue: GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS.rawValue
+	)
+	public static let disablePathSpecMatch = StatusOptions(
+		rawValue: GIT_STATUS_OPT_DISABLE_PATHSPEC_MATCH.rawValue
+	)
+	public static let recurseIgnoredDirs = StatusOptions(
+		rawValue: GIT_STATUS_OPT_RECURSE_IGNORED_DIRS.rawValue
+	)
+	public static let renamesHeadToIndex = StatusOptions(
+		rawValue: GIT_STATUS_OPT_RENAMES_HEAD_TO_INDEX.rawValue
+	)
+	public static let renamesIndexToWorkDir = StatusOptions(
+		rawValue: GIT_STATUS_OPT_RENAMES_INDEX_TO_WORKDIR.rawValue
+	)
+	public static let sortCasesSensitively = StatusOptions(
+		rawValue: GIT_STATUS_OPT_SORT_CASE_SENSITIVELY.rawValue
+	)
+	public static let sortCasesInSensitively = StatusOptions(
+		rawValue: GIT_STATUS_OPT_SORT_CASE_INSENSITIVELY.rawValue
+	)
+	public static let renamesFromRewrites = StatusOptions(
+		rawValue: GIT_STATUS_OPT_RENAMES_FROM_REWRITES.rawValue
+	)
+	public static let noRefresh = StatusOptions(
+		rawValue: GIT_STATUS_OPT_NO_REFRESH.rawValue
+	)
+	public static let updateIndex = StatusOptions(
+		rawValue: GIT_STATUS_OPT_UPDATE_INDEX.rawValue
+	)
+	public static let includeUnreadable = StatusOptions(
+		rawValue: GIT_STATUS_OPT_INCLUDE_UNREADABLE.rawValue
+	)
+	public static let includeUnreadableAsUntracked = StatusOptions(
+		rawValue: GIT_STATUS_OPT_INCLUDE_UNREADABLE_AS_UNTRACKED.rawValue
+	)
+}
@@ -6,7 +6,7 @@
 //  Copyright (c) 2014 GitHub, Inc. All rights reserved.
 //

-#import <Cocoa/Cocoa.h>
+@import Foundation;

 //! Project version number for SwiftGit2.
 FOUNDATION_EXPORT double SwiftGit2VersionNumber;
@@ -15,11 +15,3 @@ FOUNDATION_EXPORT double SwiftGit2VersionNumber;
 FOUNDATION_EXPORT const unsigned char SwiftGit2VersionString[];

 // In this header, you should import all the public headers of your framework using statements like #import <SwiftGit2/PublicHeader.h>
-
-#import "git2.h"
-
-typedef void (^SG2CheckoutProgressBlock)(NSString * __nullable, NSUInteger, NSUInteger);
-
-/// A C function for working with Libgit2. This shouldn't be called directly. It's an
-/// implementation detail that, unfortunately, leaks through to the public headers.
-extern git_checkout_options SG2CheckoutOptions(SG2CheckoutProgressBlock __nullable progress);
@@ -7,30 +7,9 @@
 //

 #import "SwiftGit2.h"
-
+#import "git2.h"

 __attribute__((constructor))
 static void SwiftGit2Init(void) {
 	git_libgit2_init();
 }
-
-static void SG2CheckoutProgressCallback(const char *path, size_t completed_steps, size_t total_steps, void *payload) {
-	if (payload == NULL) return;
-	
-	SG2CheckoutProgressBlock block = (__bridge SG2CheckoutProgressBlock)payload;
-	block((path == nil ? nil : @(path)), completed_steps, total_steps);
-}
-
-git_checkout_options SG2CheckoutOptions(SG2CheckoutProgressBlock progress) {
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wmissing-field-initializers"
-	git_checkout_options result = GIT_CHECKOUT_OPTIONS_INIT;
-#pragma clang diagnostic pop
-	
-	if (progress != nil) {
-		result.progress_cb = SG2CheckoutProgressCallback;
-		result.progress_payload = (__bridge void *)[progress copy];
-	}
-	
-	return result;
-}
@@ -1,66 +0,0 @@
-
-framework module SwiftGit2 {
-	umbrella header "SwiftGit2.h"
-  
-	header "git2/annotated_commit.h"
-	header "git2/attr.h"
-	header "git2/blame.h"
-	header "git2/blob.h"
-	header "git2/branch.h"
-	header "git2/buffer.h"
-	header "git2/checkout.h"
-	header "git2/cherrypick.h"
-	header "git2/clone.h"
-	header "git2/commit.h"
-	header "git2/common.h"
-	header "git2/config.h"
-	header "git2/cred_helpers.h"
-	header "git2/describe.h"
-	header "git2/diff.h"
-	header "git2/errors.h"
-	header "git2/filter.h"
-	header "git2/global.h"
-	header "git2/graph.h"
-	header "git2/ignore.h"
-	header "git2/index.h"
-	header "git2/indexer.h"
-	header "git2/merge.h"
-	header "git2/message.h"
-	header "git2/net.h"
-	header "git2/notes.h"
-	header "git2/object.h"
-	header "git2/odb_backend.h"
-	header "git2/odb.h"
-	header "git2/oid.h"
-	header "git2/oidarray.h"
-	header "git2/pack.h"
-	header "git2/patch.h"
-	header "git2/pathspec.h"
-	header "git2/push.h"
-	header "git2/rebase.h"
-	header "git2/refdb.h"
-	header "git2/reflog.h"
-	header "git2/refs.h"
-	header "git2/refspec.h"
-	header "git2/remote.h"
-	header "git2/repository.h"
-	header "git2/reset.h"
-	header "git2/revert.h"
-	header "git2/revparse.h"
-	header "git2/revwalk.h"
-	header "git2/signature.h"
-	header "git2/stash.h"
-	header "git2/status.h"
-	header "git2/strarray.h"
-	header "git2/submodule.h"
-	header "git2/tag.h"
-	header "git2/trace.h"
-	header "git2/transaction.h"
-	header "git2/transport.h"
-	header "git2/tree.h"
-	header "git2/types.h"
-	header "git2/version.h"
-  
-	export *
-	module * { export * }
-}
@@ -6,73 +6,69 @@
 //  Copyright (c) 2014 GitHub, Inc. All rights reserved.
 //

-import Foundation
 import SwiftGit2
+import ZipArchive

 final class Fixtures {
-	
+
 	// MARK: Lifecycle
-	
+
 	class var sharedInstance: Fixtures {
-		struct Singleton {
+		enum Singleton {
 			static let instance = Fixtures()
 		}
 		return Singleton.instance
 	}
-	
+
 	init() {
-		let path = NSTemporaryDirectory()
-			.stringByAppendingPathComponent("org.libgit2.SwiftGit2")
-			.stringByAppendingPathComponent(NSProcessInfo.processInfo().globallyUniqueString)
-		directoryURL = NSURL.fileURLWithPath(path, isDirectory: true)!
+		directoryURL = URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)
+			.appendingPathComponent("org.libgit2.SwiftGit2")
+			.appendingPathComponent(ProcessInfo.processInfo.globallyUniqueString)
 	}
-	
+
 	// MARK: - Setup and Teardown
-	
-	let directoryURL: NSURL
-	
+
+	let directoryURL: URL
+
 	func setUp() {
-		NSFileManager.defaultManager().createDirectoryAtURL(directoryURL, withIntermediateDirectories: true, attributes: nil, error: nil)
-		
-		let bundle = NSBundle(identifier: "org.libgit2.SwiftGit2-OSXTests")!
-		let zipURLs = bundle.URLsForResourcesWithExtension("zip", subdirectory: nil)! as! [NSURL]
-		
+		try! FileManager.default.createDirectory(at: directoryURL, withIntermediateDirectories: true, attributes: nil)
+
+		#if os(OSX)
+			let platform = "OSX"
+		#else
+			let platform = "iOS"
+		#endif
+		let bundleIdentifier = String(format: "org.libgit2.SwiftGit2-%@Tests", arguments: [platform])
+		let bundle = Bundle(identifier: bundleIdentifier)!
+		let zipURLs = bundle.urls(forResourcesWithExtension: "zip", subdirectory: nil)!
+
 		for URL in zipURLs {
-			unzipFileAtURL(URL, intoDirectoryAtURL: directoryURL)
+			SSZipArchive.unzipFile(atPath: URL.path, toDestination: directoryURL.path)
 		}
 	}
-	
+
 	func tearDown() {
-		NSFileManager.defaultManager().removeItemAtURL(directoryURL, error: nil)
+		try! FileManager.default.removeItem(at: directoryURL)
 	}
-	
-	func unzipFileAtURL(fileURL: NSURL, intoDirectoryAtURL directoryURL: NSURL) {
-		let task = NSTask()
-		task.launchPath = "/usr/bin/unzip"
-		task.arguments = [ "-qq", "-d", directoryURL.path!, fileURL.path! ]
-		
-		task.launch()
-		task.waitUntilExit()
-	}
-	
+
 	// MARK: - Helpers
-	
-	func repositoryWithName(name: String) -> Repository {
-		let url = directoryURL.URLByAppendingPathComponent(name, isDirectory: true)
-		return Repository.atURL(url).value!
+
+	func repository(named name: String) -> Repository {
+		let url = directoryURL.appendingPathComponent(name, isDirectory: true)
+		return Repository.at(url).value!
 	}
-	
+
 	// MARK: - The Fixtures
-	
+
 	class var detachedHeadRepository: Repository {
-		return Fixtures.sharedInstance.repositoryWithName("detached-head")
+		return Fixtures.sharedInstance.repository(named: "detached-head")
 	}
-	
+
 	class var simpleRepository: Repository {
-		return Fixtures.sharedInstance.repositoryWithName("simple-repository")
+		return Fixtures.sharedInstance.repository(named: "simple-repository")
 	}
-	
+
 	class var mantleRepository: Repository {
-		return Fixtures.sharedInstance.repositoryWithName("Mantle")
+		return Fixtures.sharedInstance.repository(named: "Mantle")
 	}
 }
@@ -9,11 +9,11 @@
 import Quick

 class FixturesSpec: QuickSpec {
-	override func spec() {
+	override class func spec() {
 		beforeSuite {
 			Fixtures.sharedInstance.setUp()
 		}
-		
+
 		afterSuite {
 			Fixtures.sharedInstance.tearDown()
 		}
@@ -7,7 +7,7 @@
 	<key>CFBundleExecutable</key>
 	<string>$(EXECUTABLE_NAME)</string>
 	<key>CFBundleIdentifier</key>
-	<string>org.libgit2.$(PRODUCT_NAME:rfc1034identifier)</string>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
 	<key>CFBundleInfoDictionaryVersion</key>
 	<string>6.0</string>
 	<key>CFBundleName</key>
@@ -6,13 +6,12 @@
 //  Copyright (c) 2014 GitHub, Inc. All rights reserved.
 //

-import Result
 import SwiftGit2
 import Nimble
 import Quick

 class OIDSpec: QuickSpec {
-	override func spec() {
+	override class func spec() {
 		describe("OID(string:)") {
 			it("should be nil if string is too short") {
 				expect(OID(string: "123456789012345678901234567890123456789")).to(beNil())
@@ -25,19 +24,19 @@ class OIDSpec: QuickSpec {
 			it("should not be nil if string is just right") {
 				expect(OID(string: "1234567890123456789012345678ABCDEFabcdef")).notTo(beNil())
 			}
-			
+
 			it("should be nil with non-hex characters") {
 				expect(OID(string: "123456789012345678901234567890123456789j")).to(beNil())
 			}
 		}
-		
+
 		describe("OID(oid)") {
 			it("should equal an OID with the same git_oid") {
 				let oid = OID(string: "1234567890123456789012345678901234567890")!
 				expect(OID(oid.oid)).to(equal(oid))
 			}
 		}
-		
+
 		describe("OID.description") {
 			it("should return the SHA") {
 				let SHA = "1234567890123456789012345678901234567890"
@@ -45,7 +44,7 @@ class OIDSpec: QuickSpec {
 				expect(oid.description).to(equal(SHA))
 			}
 		}
-		
+
 		describe("==(OID, OID)") {
 			it("should be equal when identical") {
 				let SHA = "1234567890123456789012345678901234567890"
@@ -53,14 +52,14 @@ class OIDSpec: QuickSpec {
 				let oid2 = OID(string: SHA)!
 				expect(oid1).to(equal(oid2))
 			}
-			
+
 			it("should be not equal when different") {
 				let oid1 = OID(string: "1234567890123456789012345678901234567890")!
 				let oid2 = OID(string: "0000000000000000000000000000000000000000")!
 				expect(oid1).notTo(equal(oid2))
 			}
 		}
-		
+
 		describe("OID.hashValue") {
 			it("should be equal when OIDs are equal") {
 				let SHA = "1234567890123456789012345678901234567890"
@@ -6,79 +6,81 @@
 //  Copyright (c) 2014 GitHub, Inc. All rights reserved.
 //

-import Result
 import SwiftGit2
 import Nimble
 import Quick
+import Clibgit2

-func from_git_object<T>(repository: Repository, oid: OID, f: COpaquePointer -> T) -> T {
-	let repository = repository.pointer
-	var oid = oid.oid
-	
-	var pointer: COpaquePointer = nil
-	git_object_lookup(&pointer, repository, &oid, GIT_OBJ_ANY)
-	let result = f(pointer)
-	git_object_free(pointer)
-	
-	return result
+private extension Repository {
+	func withGitObject<T>(_ oid: OID, transform: (OpaquePointer) -> T) -> T {
+		let repository = self.pointer
+		var oid = oid.oid
+
+		var pointer: OpaquePointer? = nil
+		git_object_lookup(&pointer, repository, &oid, GIT_OBJECT_ANY)
+		let result = transform(pointer!)
+		git_object_free(pointer)
+
+		return result
+	}
 }

-class SignatureSpec: QuickSpec {
-	override func spec() {
+class SignatureSpec: FixturesSpec {
+	override class func spec() {
 		describe("Signature(signature)") {
 			it("should initialize its properties") {
 				let repo = Fixtures.simpleRepository
 				let oid = OID(string: "dc220a3f0c22920dab86d4a8d3a3cb7e69d6205a")!
-				
-				let raw_signature = from_git_object(repo, oid) { git_commit_author($0).memory }
+
+				let raw_signature = repo.withGitObject(oid) { git_commit_author($0).pointee }
 				let signature = Signature(raw_signature)
-				
+
 				expect(signature.name).to(equal("Matt Diephouse"))
 				expect(signature.email).to(equal("matt@diephouse.com"))
-				expect(signature.time).to(equal(NSDate(timeIntervalSince1970: 1416186947)))
-				expect(signature.timeZone.abbreviation).to(equal("GMT-5"))
+				expect(signature.time).to(equal(Date(timeIntervalSince1970: 1416186947)))
+				expect(signature.timeZone.abbreviation()).to(equal("GMT-5"))
 			}
 		}
-		
+
 		describe("==(Signature, Signature)") {
 			it("should be true with equal objects") {
 				let repo = Fixtures.simpleRepository
 				let oid = OID(string: "dc220a3f0c22920dab86d4a8d3a3cb7e69d6205a")!
-				
-				let author1 = from_git_object(repo, oid) { commit in
-					Signature(git_commit_author(commit).memory)
+
+				let author1 = repo.withGitObject(oid) { commit in
+					Signature(git_commit_author(commit).pointee)
 				}
 				let author2 = author1
-				
+
 				expect(author1).to(equal(author2))
 			}
-			
+
 			it("should be false with unequal objects") {
 				let repo = Fixtures.simpleRepository
 				let oid1 = OID(string: "dc220a3f0c22920dab86d4a8d3a3cb7e69d6205a")!
 				let oid2 = OID(string: "24e1e40ee77525d9e279f079f9906ad6d98c8940")!
-				
-				let author1 = from_git_object(repo, oid1) { commit in
-					Signature(git_commit_author(commit).memory)
+
+				let author1 = repo.withGitObject(oid1) { commit in
+					Signature(git_commit_author(commit).pointee)
 				}
-				let author2 = from_git_object(repo, oid2) { commit in
-					Signature(git_commit_author(commit).memory)
+				let author2 = repo.withGitObject(oid2) { commit in
+					Signature(git_commit_author(commit).pointee)
 				}
-				
+
 				expect(author1).notTo(equal(author2))
 			}
 		}
-		
+
 		describe("Signature.hashValue") {
 			it("should be equal with equal objects") {
 				let repo = Fixtures.simpleRepository
 				let oid = OID(string: "dc220a3f0c22920dab86d4a8d3a3cb7e69d6205a")!
-				
-				let author1 = from_git_object(repo, oid) { commit in
-					Signature(git_commit_author(commit).memory)
+
+				let author1 = repo.withGitObject(oid) { commit in
+					Signature(git_commit_author(commit).pointee)
 				}
 				let author2 = author1
-				
+
 				expect(author1.hashValue).to(equal(author2.hashValue))
 			}
 		}
@@ -86,18 +88,18 @@ class SignatureSpec: QuickSpec {
 }

 class CommitSpec: QuickSpec {
-	override func spec() {
+	override class func spec() {
 		describe("Commit(pointer)") {
 			it("should initialize its properties") {
 				let repo = Fixtures.simpleRepository
 				let oid = OID(string: "24e1e40ee77525d9e279f079f9906ad6d98c8940")!
-				
-				let commit = from_git_object(repo, oid) { Commit($0) }
-				let author = from_git_object(repo, oid) { commit in
-					Signature(git_commit_author(commit).memory)
+
+				let commit = repo.withGitObject(oid) { Commit($0) }
+				let author = repo.withGitObject(oid) { commit in
+					Signature(git_commit_author(commit).pointee)
 				}
-				let committer = from_git_object(repo, oid) { commit in
-					Signature(git_commit_committer(commit).memory)
+				let committer = repo.withGitObject(oid) { commit in
+					Signature(git_commit_committer(commit).pointee)
 				}
 				let tree = PointerTo<Tree>(OID(string: "219e9f39c2fb59ed1dfb3e78ed75055a57528f31")!)
 				let parents: [PointerTo<Commit>] = [
@@ -110,20 +112,20 @@ class CommitSpec: QuickSpec {
 				expect(commit.author).to(equal(author))
 				expect(commit.committer).to(equal(committer))
 			}
-			
+
 			it("should handle 0 parents") {
 				let repo = Fixtures.simpleRepository
 				let oid = OID(string: "dc220a3f0c22920dab86d4a8d3a3cb7e69d6205a")!
-				
-				let commit = from_git_object(repo, oid) { Commit($0) }
+
+				let commit = repo.withGitObject(oid) { Commit($0) }
 				expect(commit.parents).to(equal([]))
 			}
-			
+
 			it("should handle multiple parents") {
 				let repo = Fixtures.simpleRepository
 				let oid = OID(string: "c4ed03a6b7d7ce837d31d83757febbe84dd465fd")!
-				
-				let commit = from_git_object(repo, oid) { Commit($0) }
+
+				let commit = repo.withGitObject(oid) { Commit($0) }
 				let parents: [PointerTo<Commit>] = [
 					PointerTo(OID(string: "315b3f344221db91ddc54b269f3c9af422da0f2e")!),
 					PointerTo(OID(string: "57f6197561d1f99b03c160f4026a07f06b43cf20")!),
@@ -131,34 +133,34 @@ class CommitSpec: QuickSpec {
 				expect(commit.parents).to(equal(parents))
 			}
 		}
-		
+
 		describe("==(Commit, Commit)") {
 			it("should be true with equal objects") {
 				let repo = Fixtures.simpleRepository
 				let oid = OID(string: "dc220a3f0c22920dab86d4a8d3a3cb7e69d6205a")!
-				
-				let commit1 = from_git_object(repo, oid) { Commit($0) }
+
+				let commit1 = repo.withGitObject(oid) { Commit($0) }
 				let commit2 = commit1
 				expect(commit1).to(equal(commit2))
 			}
-			
+
 			it("should be false with unequal objects") {
 				let repo = Fixtures.simpleRepository
 				let oid1 = OID(string: "dc220a3f0c22920dab86d4a8d3a3cb7e69d6205a")!
 				let oid2 = OID(string: "c4ed03a6b7d7ce837d31d83757febbe84dd465fd")!
-				
-				let commit1 = from_git_object(repo, oid1) { Commit($0) }
-				let commit2 = from_git_object(repo, oid2) { Commit($0) }
+
+				let commit1 = repo.withGitObject(oid1) { Commit($0) }
+				let commit2 = repo.withGitObject(oid2) { Commit($0) }
 				expect(commit1).notTo(equal(commit2))
 			}
 		}
-		
+
 		describe("Commit.hashValue") {
 			it("should be equal with equal objects") {
 				let repo = Fixtures.simpleRepository
 				let oid = OID(string: "dc220a3f0c22920dab86d4a8d3a3cb7e69d6205a")!
-				
-				let commit1 = from_git_object(repo, oid) { Commit($0) }
+
+				let commit1 = repo.withGitObject(oid) { Commit($0) }
 				let commit2 = commit1
 				expect(commit1.hashValue).to(equal(commit2.hashValue))
 			}
@@ -167,59 +169,59 @@ class CommitSpec: QuickSpec {
 }

 class TreeEntrySpec: QuickSpec {
-	override func spec() {
+	override class func spec() {
 		describe("Tree.Entry(attributes:object:name:)") {
 			it("should set its properties") {
-				let attributes = Int32(GIT_FILEMODE_BLOB.value)
-				let object = Pointer.Blob(OID(string: "41078396f5187daed5f673e4a13b185bbad71fba")!)
+				let attributes = Int32(GIT_FILEMODE_BLOB.rawValue)
+				let object = Pointer.blob(OID(string: "41078396f5187daed5f673e4a13b185bbad71fba")!)
 				let name = "README.md"
-				
+
 				let entry = Tree.Entry(attributes: attributes, object: object, name: name)
 				expect(entry.attributes).to(equal(attributes))
 				expect(entry.object).to(equal(object))
 				expect(entry.name).to(equal(name))
 			}
 		}
-		
+
 		describe("Tree.Entry(pointer)") {
 			it("should set its properties") {
 				let repo = Fixtures.simpleRepository
 				let oid = OID(string: "219e9f39c2fb59ed1dfb3e78ed75055a57528f31")!
-				
-				let entry = from_git_object(repo, oid) { Tree.Entry(git_tree_entry_byindex($0, 0)) }
-				expect(entry.attributes).to(equal(Int32(GIT_FILEMODE_BLOB.value)))
-				expect(entry.object).to(equal(Pointer.Blob(OID(string: "41078396f5187daed5f673e4a13b185bbad71fba")!)))
+
+				let entry = repo.withGitObject(oid) { Tree.Entry(git_tree_entry_byindex($0, 0)) }
+				expect(entry.attributes).to(equal(Int32(GIT_FILEMODE_BLOB.rawValue)))
+				expect(entry.object).to(equal(Pointer.blob(OID(string: "41078396f5187daed5f673e4a13b185bbad71fba")!)))
 				expect(entry.name).to(equal("README.md"))
 			}
 		}
-		
+
 		describe("==(Tree.Entry, Tree.Entry)") {
 			it("should be true with equal objects") {
 				let repo = Fixtures.simpleRepository
 				let oid = OID(string: "219e9f39c2fb59ed1dfb3e78ed75055a57528f31")!
-				
-				let entry1 = from_git_object(repo, oid) { Tree.Entry(git_tree_entry_byindex($0, 0)) }
+
+				let entry1 = repo.withGitObject(oid) { Tree.Entry(git_tree_entry_byindex($0, 0)) }
 				let entry2 = entry1
 				expect(entry1).to(equal(entry2))
 			}
-			
+
 			it("should be false with unequal objects") {
 				let repo = Fixtures.simpleRepository
 				let oid1 = OID(string: "219e9f39c2fb59ed1dfb3e78ed75055a57528f31")!
 				let oid2 = OID(string: "f93e3a1a1525fb5b91020da86e44810c87a2d7bc")!
-				
-				let entry1 = from_git_object(repo, oid1) { Tree.Entry(git_tree_entry_byindex($0, 0)) }
-				let entry2 = from_git_object(repo, oid2) { Tree.Entry(git_tree_entry_byindex($0, 0)) }
+
+				let entry1 = repo.withGitObject(oid1) { Tree.Entry(git_tree_entry_byindex($0, 0)) }
+				let entry2 = repo.withGitObject(oid2) { Tree.Entry(git_tree_entry_byindex($0, 0)) }
 				expect(entry1).notTo(equal(entry2))
 			}
 		}
-		
+
 		describe("Tree.Entry.hashValue") {
 			it("should be equal with equal objects") {
 				let repo = Fixtures.simpleRepository
 				let oid = OID(string: "219e9f39c2fb59ed1dfb3e78ed75055a57528f31")!
-				
-				let entry1 = from_git_object(repo, oid) { Tree.Entry(git_tree_entry_byindex($0, 0)) }
+
+				let entry1 = repo.withGitObject(oid) { Tree.Entry(git_tree_entry_byindex($0, 0)) }
 				let entry2 = entry1
 				expect(entry1.hashValue).to(equal(entry2.hashValue))
 			}
@@ -228,47 +230,49 @@ class TreeEntrySpec: QuickSpec {
 }

 class TreeSpec: QuickSpec {
-	override func spec() {
+	override class func spec() {
 		describe("Tree(pointer)") {
 			it("should initialize its properties") {
 				let repo = Fixtures.simpleRepository
 				let oid = OID(string: "219e9f39c2fb59ed1dfb3e78ed75055a57528f31")!
-				
-				let tree = from_git_object(repo, oid) { Tree($0) }
+
+				let tree = repo.withGitObject(oid) { Tree($0) }
 				let entries = [
-					"README.md": Tree.Entry(attributes: Int32(GIT_FILEMODE_BLOB.value), object: .Blob(OID(string: "41078396f5187daed5f673e4a13b185bbad71fba")!), name: "README.md"),
+					"README.md": Tree.Entry(attributes: Int32(GIT_FILEMODE_BLOB.rawValue),
+					                        object: .blob(OID(string: "41078396f5187daed5f673e4a13b185bbad71fba")!),
+					                        name: "README.md"),
 				]
 				expect(tree.entries).to(equal(entries))
 			}
 		}
-		
+
 		describe("==(Tree, Tree)") {
 			it("should be true with equal objects") {
 				let repo = Fixtures.simpleRepository
 				let oid = OID(string: "219e9f39c2fb59ed1dfb3e78ed75055a57528f31")!
-				
-				let tree1 = from_git_object(repo, oid) { Tree($0) }
+
+				let tree1 = repo.withGitObject(oid) { Tree($0) }
 				let tree2 = tree1
 				expect(tree1).to(equal(tree2))
 			}
-			
+
 			it("should be false with unequal objects") {
 				let repo = Fixtures.simpleRepository
 				let oid1 = OID(string: "219e9f39c2fb59ed1dfb3e78ed75055a57528f31")!
 				let oid2 = OID(string: "f93e3a1a1525fb5b91020da86e44810c87a2d7bc")!
-				
-				let tree1 = from_git_object(repo, oid1) { Tree($0) }
-				let tree2 = from_git_object(repo, oid2) { Tree($0) }
+
+				let tree1 = repo.withGitObject(oid1) { Tree($0) }
+				let tree2 = repo.withGitObject(oid2) { Tree($0) }
 				expect(tree1).notTo(equal(tree2))
 			}
 		}
-		
+
 		describe("Tree.hashValue") {
 			it("should be equal with equal objects") {
 				let repo = Fixtures.simpleRepository
 				let oid = OID(string: "219e9f39c2fb59ed1dfb3e78ed75055a57528f31")!
-				
-				let tree1 = from_git_object(repo, oid) { Tree($0) }
+
+				let tree1 = repo.withGitObject(oid) { Tree($0) }
 				let tree2 = tree1
 				expect(tree1.hashValue).to(equal(tree2.hashValue))
 			}
@@ -277,47 +281,47 @@ class TreeSpec: QuickSpec {
 }

 class BlobSpec: QuickSpec {
-	override func spec() {
+	override class func spec() {
 		describe("Blob(pointer)") {
 			it("should initialize its properties") {
 				let repo = Fixtures.simpleRepository
 				let oid = OID(string: "41078396f5187daed5f673e4a13b185bbad71fba")!
-				
-				let blob = from_git_object(repo, oid) { Blob($0) }
+
+				let blob = repo.withGitObject(oid) { Blob($0) }
 				let contents = "# Simple Repository\nA simple repository used for testing SwiftGit2.\n\n## Branches\n\n- master\n\n"
-				let data = (contents as NSString).dataUsingEncoding(NSUTF8StringEncoding)!
+				let data = contents.data(using: String.Encoding.utf8)!
 				expect(blob.oid).to(equal(oid))
 				expect(blob.data).to(equal(data))
 			}
 		}
-		
+
 		describe("==(Blob, Blob)") {
 			it("should be true with equal objects") {
 				let repo = Fixtures.simpleRepository
 				let oid = OID(string: "41078396f5187daed5f673e4a13b185bbad71fba")!
-				
-				let blob1 = from_git_object(repo, oid) { Blob($0) }
+
+				let blob1 = repo.withGitObject(oid) { Blob($0) }
 				let blob2 = blob1
 				expect(blob1).to(equal(blob2))
 			}
-			
+
 			it("should be false with unequal objects") {
 				let repo = Fixtures.simpleRepository
 				let oid1 = OID(string: "41078396f5187daed5f673e4a13b185bbad71fba")!
 				let oid2 = OID(string: "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391")!
-				
-				let blob1 = from_git_object(repo, oid1) { Blob($0) }
-				let blob2 = from_git_object(repo, oid2) { Blob($0) }
+
+				let blob1 = repo.withGitObject(oid1) { Blob($0) }
+				let blob2 = repo.withGitObject(oid2) { Blob($0) }
 				expect(blob1).notTo(equal(blob2))
 			}
 		}
-		
+
 		describe("Blob.hashValue") {
 			it("should be equal with equal objects") {
 				let repo = Fixtures.simpleRepository
 				let oid = OID(string: "41078396f5187daed5f673e4a13b185bbad71fba")!
-				
-				let blob1 = from_git_object(repo, oid) { Blob($0) }
+
+				let blob1 = repo.withGitObject(oid) { Blob($0) }
 				let blob2 = blob1
 				expect(blob1.hashValue).to(equal(blob2.hashValue))
 			}
@@ -326,50 +330,50 @@ class BlobSpec: QuickSpec {
 }

 class TagSpec: QuickSpec {
-	override func spec() {
+	override class func spec() {
 		describe("Tag(pointer)") {
 			it("should set its properties") {
 				let repo = Fixtures.simpleRepository
 				let oid = OID(string: "57943b8ee00348180ceeedc960451562750f6d33")!
-				
-				let tag = from_git_object(repo, oid) { Tag($0) }
-				let tagger = from_git_object(repo, oid) { Signature(git_tag_tagger($0).memory) }
-				
+
+				let tag = repo.withGitObject(oid) { Tag($0) }
+				let tagger = repo.withGitObject(oid) { Signature(git_tag_tagger($0).pointee) }
+
 				expect(tag.oid).to(equal(oid))
-				expect(tag.target).to(equal(Pointer.Commit(OID(string: "dc220a3f0c22920dab86d4a8d3a3cb7e69d6205a")!)))
+				expect(tag.target).to(equal(Pointer.commit(OID(string: "dc220a3f0c22920dab86d4a8d3a3cb7e69d6205a")!)))
 				expect(tag.name).to(equal("tag-1"))
 				expect(tag.tagger).to(equal(tagger))
 				expect(tag.message).to(equal("tag-1\n"))
 			}
 		}
-		
+
 		describe("==(Tag, Tag)") {
 			it("should be true with equal objects") {
 				let repo = Fixtures.simpleRepository
 				let oid = OID(string: "57943b8ee00348180ceeedc960451562750f6d33")!
-				
-				let tag1 = from_git_object(repo, oid) { Tag($0) }
+
+				let tag1 = repo.withGitObject(oid) { Tag($0) }
 				let tag2 = tag1
 				expect(tag1).to(equal(tag2))
 			}
-			
+
 			it("should be false with unequal objects") {
 				let repo = Fixtures.simpleRepository
 				let oid1 = OID(string: "57943b8ee00348180ceeedc960451562750f6d33")!
 				let oid2 = OID(string: "13bda91157f255ab224ff88d0a11a82041c9d0c1")!
-				
-				let tag1 = from_git_object(repo, oid1) { Tag($0) }
-				let tag2 = from_git_object(repo, oid2) { Tag($0) }
+
+				let tag1 = repo.withGitObject(oid1) { Tag($0) }
+				let tag2 = repo.withGitObject(oid2) { Tag($0) }
 				expect(tag1).notTo(equal(tag2))
 			}
 		}
-		
+
 		describe("Tag.hashValue") {
 			it("should be equal with equal objects") {
 				let repo = Fixtures.simpleRepository
 				let oid = OID(string: "57943b8ee00348180ceeedc960451562750f6d33")!
-				
-				let tag1 = from_git_object(repo, oid) { Tag($0) }
+
+				let tag1 = repo.withGitObject(oid) { Tag($0) }
 				let tag2 = tag1
 				expect(tag1.hashValue).to(equal(tag2.hashValue))
 			}
@@ -6,46 +6,48 @@
 //  Copyright (c) 2015 GitHub, Inc. All rights reserved.
 //

-import Result
 import SwiftGit2
 import Nimble
 import Quick
+import Clibgit2

-func from_git_reference<T>(repository: Repository, name: String, f: COpaquePointer -> T) -> T {
-	let repository = repository.pointer
-	
-	var pointer: COpaquePointer = nil
-	git_reference_lookup(&pointer, repository, name)
-	let result = f(pointer)
-	git_object_free(pointer)
-	
-	return result
+private extension Repository {
+	func withGitReference<T>(named name: String, transform: (OpaquePointer) -> T) -> T {
+		let repository = self.pointer
+
+		var pointer: OpaquePointer? = nil
+		git_reference_lookup(&pointer, repository, name)
+		let result = transform(pointer!)
+		git_reference_free(pointer)
+
+		return result
+	}
 }

-class ReferenceSpec: QuickSpec {
-	override func spec() {
+class ReferenceSpec: FixturesSpec {
+	override class func spec() {
 		describe("Reference(pointer)") {
 			it("should initialize its properties") {
 				let repo = Fixtures.simpleRepository
-				let ref = from_git_reference(repo, "refs/heads/master") { Reference($0) }
+				let ref = repo.withGitReference(named: "refs/heads/master") { Reference($0) }
 				expect(ref.longName).to(equal("refs/heads/master"))
 				expect(ref.shortName).to(equal("master"))
 				expect(ref.oid).to(equal(OID(string: "c4ed03a6b7d7ce837d31d83757febbe84dd465fd")!))
 			}
 		}
-		
+
 		describe("==(Reference, Reference)") {
 			it("should be true with equal references") {
 				let repo = Fixtures.simpleRepository
-				let ref1 = from_git_reference(repo, "refs/heads/master") { Reference($0) }
-				let ref2 = from_git_reference(repo, "refs/heads/master") { Reference($0) }
+				let ref1 = repo.withGitReference(named: "refs/heads/master") { Reference($0) }
+				let ref2 = repo.withGitReference(named: "refs/heads/master") { Reference($0) }
 				expect(ref1).to(equal(ref2))
 			}
-			
+
 			it("should be false with unequal references") {
 				let repo = Fixtures.simpleRepository
-				let ref1 = from_git_reference(repo, "refs/heads/master") { Reference($0) }
-				let ref2 = from_git_reference(repo, "refs/heads/another-branch") { Reference($0) }
+				let ref1 = repo.withGitReference(named: "refs/heads/master") { Reference($0) }
+				let ref2 = repo.withGitReference(named: "refs/heads/another-branch") { Reference($0) }
 				expect(ref1).notTo(equal(ref2))
 			}
 		}
@@ -53,8 +55,8 @@ class ReferenceSpec: QuickSpec {
 		describe("Reference.hashValue") {
 			it("should be equal with equal references") {
 				let repo = Fixtures.simpleRepository
-				let ref1 = from_git_reference(repo, "refs/heads/master") { Reference($0) }
-				let ref2 = from_git_reference(repo, "refs/heads/master") { Reference($0) }
+				let ref1 = repo.withGitReference(named: "refs/heads/master") { Reference($0) }
+				let ref2 = repo.withGitReference(named: "refs/heads/master") { Reference($0) }
 				expect(ref1.hashValue).to(equal(ref2.hashValue))
 			}
 		}
@@ -62,11 +64,11 @@ class ReferenceSpec: QuickSpec {
 }

 class BranchSpec: QuickSpec {
-	override func spec() {
+	override class func spec() {
 		describe("Branch(pointer)") {
 			it("should initialize its properties") {
 				let repo = Fixtures.mantleRepository
-				let branch = from_git_reference(repo, "refs/heads/master") { Branch($0)! }
+				let branch = repo.withGitReference(named: "refs/heads/master") { Branch($0)! }
 				expect(branch.longName).to(equal("refs/heads/master"))
 				expect(branch.name).to(equal("master"))
 				expect(branch.shortName).to(equal(branch.name))
@@ -75,10 +77,10 @@ class BranchSpec: QuickSpec {
 				expect(branch.isLocal).to(beTrue())
 				expect(branch.isRemote).to(beFalse())
 			}
-			
+
 			it("should work with symoblic refs") {
 				let repo = Fixtures.mantleRepository
-				let branch = from_git_reference(repo, "refs/remotes/origin/HEAD") { Branch($0)! }
+				let branch = repo.withGitReference(named: "refs/remotes/origin/HEAD") { Branch($0)! }
 				expect(branch.longName).to(equal("refs/remotes/origin/HEAD"))
 				expect(branch.name).to(equal("origin/HEAD"))
 				expect(branch.shortName).to(equal(branch.name))
@@ -88,19 +90,19 @@ class BranchSpec: QuickSpec {
 				expect(branch.isRemote).to(beTrue())
 			}
 		}
-		
+
 		describe("==(Branch, Branch)") {
 			it("should be true with equal branches") {
 				let repo = Fixtures.simpleRepository
-				let branch1 = from_git_reference(repo, "refs/heads/master") { Branch($0)! }
-				let branch2 = from_git_reference(repo, "refs/heads/master") { Branch($0)! }
+				let branch1 = repo.withGitReference(named: "refs/heads/master") { Branch($0)! }
+				let branch2 = repo.withGitReference(named: "refs/heads/master") { Branch($0)! }
 				expect(branch1).to(equal(branch2))
 			}
-			
+
 			it("should be false with unequal branches") {
 				let repo = Fixtures.simpleRepository
-				let branch1 = from_git_reference(repo, "refs/heads/master") { Branch($0)! }
-				let branch2 = from_git_reference(repo, "refs/heads/another-branch") { Branch($0)! }
+				let branch1 = repo.withGitReference(named: "refs/heads/master") { Branch($0)! }
+				let branch2 = repo.withGitReference(named: "refs/heads/another-branch") { Branch($0)! }
 				expect(branch1).notTo(equal(branch2))
 			}
 		}
@@ -108,8 +110,8 @@ class BranchSpec: QuickSpec {
 		describe("Branch.hashValue") {
 			it("should be equal with equal references") {
 				let repo = Fixtures.simpleRepository
-				let branch1 = from_git_reference(repo, "refs/heads/master") { Branch($0)! }
-				let branch2 = from_git_reference(repo, "refs/heads/master") { Branch($0)! }
+				let branch1 = repo.withGitReference(named: "refs/heads/master") { Branch($0)! }
+				let branch2 = repo.withGitReference(named: "refs/heads/master") { Branch($0)! }
 				expect(branch1.hashValue).to(equal(branch2.hashValue))
 			}
 		}
@@ -117,45 +119,45 @@ class BranchSpec: QuickSpec {
 }

 class TagReferenceSpec: QuickSpec {
-	override func spec() {
+	override class func spec() {
 		describe("TagReference(pointer)") {
 			it("should work with an annotated tag") {
 				let repo = Fixtures.simpleRepository
-				let tag = from_git_reference(repo, "refs/tags/tag-2") { TagReference($0)! }
+				let tag = repo.withGitReference(named: "refs/tags/tag-2") { TagReference($0)! }
 				expect(tag.longName).to(equal("refs/tags/tag-2"))
 				expect(tag.name).to(equal("tag-2"))
 				expect(tag.shortName).to(equal(tag.name))
 				expect(tag.oid).to(equal(OID(string: "24e1e40ee77525d9e279f079f9906ad6d98c8940")!))
 			}
-			
+
 			it("should work with a lightweight tag") {
 				let repo = Fixtures.mantleRepository
-				let tag = from_git_reference(repo, "refs/tags/1.5.4") { TagReference($0)! }
+				let tag = repo.withGitReference(named: "refs/tags/1.5.4") { TagReference($0)! }
 				expect(tag.longName).to(equal("refs/tags/1.5.4"))
 				expect(tag.name).to(equal("1.5.4"))
 				expect(tag.shortName).to(equal(tag.name))
 				expect(tag.oid).to(equal(OID(string: "d9dc95002cfbf3929d2b70d2c8a77e6bf5b1b88a")!))
 			}
-			
+
 			it("should return nil if not a tag") {
 				let repo = Fixtures.simpleRepository
-				let tag = from_git_reference(repo, "refs/heads/master") { TagReference($0) }
+				let tag = repo.withGitReference(named: "refs/heads/master") { TagReference($0) }
 				expect(tag).to(beNil())
 			}
 		}
-		
+
 		describe("==(TagReference, TagReference)") {
 			it("should be true with equal tag references") {
 				let repo = Fixtures.simpleRepository
-				let tag1 = from_git_reference(repo, "refs/tags/tag-2") { TagReference($0)! }
-				let tag2 = from_git_reference(repo, "refs/tags/tag-2") { TagReference($0)! }
+				let tag1 = repo.withGitReference(named: "refs/tags/tag-2") { TagReference($0)! }
+				let tag2 = repo.withGitReference(named: "refs/tags/tag-2") { TagReference($0)! }
 				expect(tag1).to(equal(tag2))
 			}
-			
+
 			it("should be false with unequal tag references") {
 				let repo = Fixtures.simpleRepository
-				let tag1 = from_git_reference(repo, "refs/tags/tag-1") { TagReference($0)! }
-				let tag2 = from_git_reference(repo, "refs/tags/tag-2") { TagReference($0)! }
+				let tag1 = repo.withGitReference(named: "refs/tags/tag-1") { TagReference($0)! }
+				let tag2 = repo.withGitReference(named: "refs/tags/tag-2") { TagReference($0)! }
 				expect(tag1).notTo(equal(tag2))
 			}
 		}
@@ -163,8 +165,8 @@ class TagReferenceSpec: QuickSpec {
 		describe("TagReference.hashValue") {
 			it("should be equal with equal references") {
 				let repo = Fixtures.simpleRepository
-				let tag1 = from_git_reference(repo, "refs/tags/tag-2") { TagReference($0)! }
-				let tag2 = from_git_reference(repo, "refs/tags/tag-2") { TagReference($0)! }
+				let tag1 = repo.withGitReference(named: "refs/tags/tag-2") { TagReference($0)! }
+				let tag2 = repo.withGitReference(named: "refs/tags/tag-2") { TagReference($0)! }
 				expect(tag1.hashValue).to(equal(tag2.hashValue))
 			}
 		}
@@ -6,54 +6,56 @@
 //  Copyright (c) 2015 GitHub, Inc. All rights reserved.
 //

-import Result
 import SwiftGit2
 import Nimble
 import Quick
+import Clibgit2

-func with_git_remote<T>(repository: Repository, name: String, f: COpaquePointer -> T) -> T {
-	let repository = repository.pointer
-	
-	var pointer: COpaquePointer = nil
-	git_remote_lookup(&pointer, repository, name)
-	let result = f(pointer)
-	git_object_free(pointer)
-	
-	return result
+private extension Repository {
+	func withGitRemote<T>(named name: String, transform: (OpaquePointer) -> T) -> T {
+		let repository = self.pointer
+
+		var pointer: OpaquePointer? = nil
+		git_remote_lookup(&pointer, repository, name)
+		let result = transform(pointer!)
+		git_remote_free(pointer)
+
+		return result
+	}
 }

-class RemoteSpec: QuickSpec {
-	override func spec() {
+class RemoteSpec: FixturesSpec {
+	override class func spec() {
 		describe("Remote(pointer)") {
 			it("should initialize its properties") {
 				let repo = Fixtures.mantleRepository
-				let remote = with_git_remote(repo, "upstream") { Remote($0) }
-				
+				let remote = repo.withGitRemote(named: "upstream") { Remote($0) }
+
 				expect(remote.name).to(equal("upstream"))
 				expect(remote.URL).to(equal("git@github.com:Mantle/Mantle.git"))
 			}
 		}
-		
+
 		describe("==(Remote, Remote)") {
 			it("should be true with equal objects") {
 				let repo = Fixtures.mantleRepository
-				let remote1 = with_git_remote(repo, "upstream") { Remote($0) }
+				let remote1 = repo.withGitRemote(named: "upstream") { Remote($0) }
 				let remote2 = remote1
 				expect(remote1).to(equal(remote2))
 			}
-			
+
 			it("should be false with unequal objcets") {
 				let repo = Fixtures.mantleRepository
-				let origin = with_git_remote(repo, "origin") { Remote($0) }
-				let upstream = with_git_remote(repo, "upstream") { Remote($0) }
+				let origin = repo.withGitRemote(named: "origin") { Remote($0) }
+				let upstream = repo.withGitRemote(named: "upstream") { Remote($0) }
 				expect(origin).notTo(equal(upstream))
 			}
 		}
-		
+
 		describe("Remote.hashValue") {
 			it("should be equal with equal objcets") {
 				let repo = Fixtures.mantleRepository
-				let remote1 = with_git_remote(repo, "upstream") { Remote($0) }
+				let remote1 = repo.withGitRemote(named: "upstream") { Remote($0) }
 				let remote2 = remote1
 				expect(remote1.hashValue).to(equal(remote2.hashValue))
 			}
@@ -0,0 +1,16 @@
+// Once Nimble adds matchers for the Result type, remove these shims and refactor the tests that use them.
+extension Result {
+	var value: Success? {
+		guard case .success(let value) = self else {
+			return nil
+		}
+		return value
+	}
+
+	var error: Failure? {
+		guard case .failure(let error) = self else {
+			return nil
+		}
+		return error
+	}
+}
@@ -0,0 +1 @@
+../External/libgit2/include/git2
@@ -0,0 +1 @@
+../External/libgit2/include/git2.h
@@ -0,0 +1,31 @@
+module Clibgit2 {
+	umbrella header "git2.h"
+
+	export *
+	module * { export * }
+
+	// Exclude headers intended only for Microsoft compilers
+	exclude header "git2/inttypes.h"
+	exclude header "git2/stdint.h"
+
+	// Explicit modules for headers not included in the umbrella header:
+	explicit module cred_helpers {
+		header "git2/cred_helpers.h"
+
+		export *
+	}
+
+	explicit module trace {
+		header "git2/trace.h"
+
+		export *
+	}
+
+	// Explicit module for the "sys" headers:
+	explicit module sys {
+		umbrella "git2/sys"
+
+		export *
+		module * { export * }
+	}
+}
@@ -1,18 +0,0 @@
-**Copyright (c) 2013 Justin Spahr-Summers**
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@@ -1,82 +0,0 @@
-# objc-build-scripts
-
-This project is a collection of scripts created with two goals:
-
- 1. To standardize how Objective-C projects are bootstrapped after cloning
- 1. To easily build Objective-C projects on continuous integration servers
-
-## Scripts
-
-Right now, there are two important scripts: [`bootstrap`](#bootstrap) and
-[`cibuild`](#cibuild). Both are Bash scripts, to maximize compatibility and
-eliminate pesky system configuration issues (like setting up a working Ruby
-environment).
-
-The structure of the scripts on disk is meant to follow that of a typical Ruby
-project:
-
-```
-script/
-    bootstrap
-    cibuild
-```
-
-### bootstrap
-
-This script is responsible for bootstrapping (initializing) your project after
-it's been checked out. Here, you should install or clone any dependencies that
-are required for a working build and development environment.
-
-By default, the script will verify that [xctool][] is installed, then initialize
-and update submodules recursively. If any submodules contain `script/bootstrap`,
-that will be run as well.
-
-To check that other tools are installed, you can set the `REQUIRED_TOOLS`
-environment variable before running `script/bootstrap`, or edit it within the
-script directly. Note that no installation is performed automatically, though
-this can always be added within your specific project.
-
-### cibuild
-
-This script is responsible for building the project, as you would want it built
-for continuous integration. This is preferable to putting the logic on the CI
-server itself, since it ensures that any changes are versioned along with the
-source.
-
-By default, the script will run [`bootstrap`](#bootstrap), look for any Xcode
-workspace or project in the working directory, then build all targets/schemes
-(as found by `xcodebuild -list`) using [xctool][].
-
-You can also specify the schemes to build by passing them into the script:
-
-```sh
-script/cibuild ReactiveCocoa-Mac ReactiveCocoa-iOS
-```
-
-As with the `bootstrap` script, there are several environment variables that can
-be used to customize behavior. They can be set on the command line before
-invoking the script, or the defaults changed within the script directly.
-
-## Getting Started
-
-To add the scripts to your project, read the contents of this repository into
-a `script` folder:
-
-```
-$ git remote add objc-build-scripts https://github.com/jspahrsummers/objc-build-scripts.git
-$ git fetch objc-build-scripts
-$ git read-tree --prefix=script/ -u objc-build-scripts/master
-```
-
-Then commit the changes, to incorporate the scripts into your own repository's
-history. You can also freely tweak the scripts for your specific project's
-needs.
-
-To merge in upstream changes later:
-
-```
-$ git fetch -p objc-build-scripts
-$ git merge --ff --squash -Xsubtree=script objc-build-scripts/master
-```
-
-[xctool]: https://github.com/facebook/xctool
@@ -9,7 +9,8 @@ export SCRIPT_DIR=$(dirname "$0")
 config ()
 {
    # A whitespace-separated list of executables that must be present and locatable.
-    : ${REQUIRED_TOOLS="xctool cmake"}
+    # These will each be installed through Homebrew if not found.
+    : ${REQUIRED_TOOLS="cmake libssh2 libtool autoconf automake pkg-config"}

    export REQUIRED_TOOLS
 }
@@ -22,12 +23,6 @@ main ()
 {
    config

-    if [ -n "$REQUIRED_TOOLS" ]
-    then
-        echo "*** Checking dependencies..."
-        check_deps
-    fi
-
    local submodules=$(git submodule status)
    local result=$?

@@ -41,28 +36,38 @@ main ()
        echo "*** Updating submodules..."
        update_submodules
    fi
+
+    if [ -n "$REQUIRED_TOOLS" ]
+    then
+        echo "*** Checking dependencies..."
+        check_deps
+    fi
 }

 check_deps ()
 {
-    for tool in $REQUIRED_TOOLS
-    do
-        which -s "$tool"
-        if [ "$?" -ne "0" ]
-        then
-            echo "*** Error: $tool not found. Please install it and bootstrap again."
-            exit 1
-        fi
-    done
+    # Check if Homebrew is installed
+    which -s brew
+    local result=$?
+
+    if [ "$result" -ne "0" ]
+    then
+        echo
+        echo "Homebrew is not installed (http://brew.sh). You will need to manually ensure the following tools are installed:"
+        echo "  $REQUIRED_TOOLS"
+        echo
+        echo "Additionally, the following libssh2 files must be symlinked under /usr/local:"
+        echo "  lib/libssh2.a include/libssh2.h include/libssh2_sftp.h include/libssh2_publickey.h"
+        exit $result
+    fi

    # Ensure that we have libgit2's dependencies installed.
    installed=`brew list`
-    libs="libssh2 libtool autoconf automake"

-    for lib in $libs
+    for tool in $REQUIRED_TOOLS
    do
        # Skip packages that are already installed.
-        echo "$installed" | grep -q "$lib" && code=$? || code=$?
+        echo "$installed" | grep -q "$tool" && code=$? || code=$?

        if [ "$code" -eq "0" ]
        then
@@ -72,12 +77,12 @@ check_deps ()
            exit $code
        fi

-        echo "*** Installing $lib with Homebrew..."
-        brew install "$lib"
+        echo "*** Installing $tool with Homebrew..."
+        brew install "$tool"
    done

    brew_prefix=`brew --prefix`
-    expected_prefix=/usr/local
+    expected_prefix=/opt/homebrew

    if [ "$brew_prefix" != "$expected_prefix" ]
    then
@@ -114,7 +119,9 @@ bootstrap_submodule ()

 update_submodules ()
 {
-    git submodule sync --quiet && git submodule update --init && git submodule foreach --quiet bootstrap_submodule
+    git submodule sync --quiet && \
+        git submodule update --init && \
+        git submodule foreach --quiet bootstrap_submodule
 }

 export -f bootstrap_submodule
@@ -1,150 +1,86 @@
-#!/bin/bash
+#!/bin/bash -ex
+#
+# script/cibuild
+# SwiftGit2
+#
+# Executes the build and runs tests for Mac and iOS. Designed to be invoked by
+# Travis as a matrix build so that the two platform builds can run in parallel.
+#
+# Dependent tools & scripts:
+# - script/bootstrap
+# - script/update_libssl_ios
+# - [xcodebuild](https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man1/xcodebuild.1.html)
+# - xcpretty (gem)
+# - xcpretty-travis-formatter (gem)
+#
+# Environment Variables:
+# - SCHEME: specifies which Xcode scheme to build. Set to one of the following:
+#   - SwiftGit2-OSX
+#   - SwiftGit2-iOS
+# - TRAVIS: indicates when the build is being run by travis, used to invoke
+#           the xcpretty-travis-formatter gem for output.
+
+if [ -z "$SCHEME" ]; then
+  echo "The SCHEME environment variable is empty. Please set this to one of:"
+  echo "- SwiftGit2-OSX"
+  echo "- SwiftGit2-iOS"
+  exit 1
+fi

-export SCRIPT_DIR=$(dirname "$0")

 ##
 ## Configuration Variables
 ##

-SCHEMES="$@"
+set -o pipefail
+SCRIPT_DIR=$(dirname "$0")
+XCWORKSPACE="SwiftGit2.xcworkspace"
+XCODE_OPTIONS=$(RUN_CLANG_STATIC_ANALYZER=NO ONLY_ACTIVE_ARCH=NO CODE_SIGN_IDENTITY="" CODE_SIGNING_REQUIRED=NO)

-config ()
-{
-    # The workspace to build.
-    #
-    # If not set and no workspace is found, the -workspace flag will not be passed
-    # to `xctool`.
-    #
-    # Only one of `XCWORKSPACE` and `XCODEPROJ` needs to be set. The former will
-    # take precedence.
-    : ${XCWORKSPACE=$(find_pattern "*.xcworkspace")}
-
-    # The project to build.
-    #
-    # If not set and no project is found, the -project flag will not be passed
-    # to `xctool`.
-    #
-    # Only one of `XCWORKSPACE` and `XCODEPROJ` needs to be set. The former will
-    # take precedence.
-    : ${XCODEPROJ=$(find_pattern "*.xcodeproj")}
-
-    # A bootstrap script to run before building.
-    #
-    # If this file does not exist, it is not considered an error.
-    : ${BOOTSTRAP="$SCRIPT_DIR/bootstrap"}
-
-    # Extra options to pass to xctool.
-    : ${XCTOOL_OPTIONS="RUN_CLANG_STATIC_ANALYZER=NO"}
-
-    # A whitespace-separated list of default schemes to build.
-    #
-    # Individual names can be quoted to avoid word splitting.
-    : ${SCHEMES:=$(xcodebuild -list -project "$XCODEPROJ" 2>/dev/null | awk -f "$SCRIPT_DIR/schemes.awk")}
-
-    export XCWORKSPACE
-    export XCODEPROJ
-    export BOOTSTRAP
-    export XCTOOL_OPTIONS
-    export SCHEMES
-}
+if [ -n "$TRAVIS" ]; then
+    # Use a special formatter when running on TravisCI
+    XCPRETTY_FORMAT_OPTIONS="-f `xcpretty-travis-formatter`"
+else
+    XCPRETTY_FORMAT_OPTIONS="--color"
+fi

 ##
 ## Build Process
 ##

-main ()
-{
-    config
+echo "*** Bootstrapping..."
+"$SCRIPT_DIR/bootstrap"

-    if [ -f "$BOOTSTRAP" ]
-    then
-        echo "*** Bootstrapping..."
-        "$BOOTSTRAP" || exit $?
-    fi
+if [ "$SCHEME" == "SwiftGit2-OSX" ]; then
+  echo "*** Building and testing $SCHEME..."
+  echo

-    echo "*** The following schemes will be built:"
-    echo "$SCHEMES" | xargs -n 1 echo "  "
-    echo
+  xcodebuild -workspace "$XCWORKSPACE" \
+    -scheme "$SCHEME" \
+    ${XCODE_OPTIONS[*]} \
+    build test \
+    2>&1 | xcpretty $XCPRETTY_FORMAT_OPTIONS
+elif [ "$SCHEME" == "SwiftGit2-iOS" ]; then
+  echo "*** Prebuilding OpenSSL"
+  "$SCRIPT_DIR/update_libssl_ios"

-    echo "$SCHEMES" | xargs -n 1 | (
-        local status=0
+  echo "*** Creating a simulator for testing..."
+  # Create a new simulator device and reference it by id to avoid xcodebuild exit status 70 with the following errors: 
+  #   "The requested device could not be found because no available devices matched the request."
+  #   "The requested device could not be found because multiple devices matched the request."
+  SIMULATOR_NAME="Custom Simulator"
+  DEVICE_ID=com.apple.CoreSimulator.SimDeviceType.iPhone-X
+  RUNTIME_ID=com.apple.CoreSimulator.SimRuntime.iOS-11-4
+  DESTINATION_ID=$(xcrun simctl create "$SIMULATOR_NAME" $DEVICE_ID $RUNTIME_ID)

-        while read scheme
-        do
-            build_scheme "$scheme" || status=1
-        done
+  echo "*** Building and testing $SCHEME..."
+  echo

-        exit $status
-    )
-}
-
-find_pattern ()
-{
-    ls -d $1 2>/dev/null | head -n 1
-}
-
-run_xctool ()
-{
-    if [ -n "$XCWORKSPACE" ]
-    then
-        xctool -workspace "$XCWORKSPACE" $XCTOOL_OPTIONS "$@" 2>&1
-    elif [ -n "$XCODEPROJ" ]
-    then
-        xctool -project "$XCODEPROJ" $XCTOOL_OPTIONS "$@" 2>&1
-    else
-        echo "*** No workspace or project file found."
-        exit 1
-    fi
-}
-
-parse_build ()
-{
-    awk -f "$SCRIPT_DIR/xctool.awk" 2>&1 >/dev/null
-}
-
-build_scheme ()
-{
-    local scheme=$1
-
-    echo "*** Building and testing $scheme..."
-    echo
-
-    local sdkflag=
-    local action=test
-
-    # Determine whether we can run unit tests for this target.
-    run_xctool -scheme "$scheme" run-tests | parse_build
-
-    local awkstatus=$?
-
-    if [ "$awkstatus" -eq "1" ]
-    then
-        # SDK not found, try for iphonesimulator.
-        sdkflag="-sdk iphonesimulator"
-
-        # Determine whether the unit tests will run with iphonesimulator
-        run_xctool $sdkflag -scheme "$scheme" run-tests | parse_build
-
-        awkstatus=$?
-
-        if [ "$awkstatus" -ne "0" ]
-        then
-            # Unit tests will not run on iphonesimulator.
-            sdkflag=""
-        fi
-    fi
-
-    if [ "$awkstatus" -ne "0" ]
-    then
-        # Unit tests aren't supported.
-        action=build
-    fi
-
-    run_xctool $sdkflag -scheme "$scheme" $action
-}
-
-export -f build_scheme
-export -f run_xctool
-export -f parse_build
-
-main
+  xcodebuild -workspace "$XCWORKSPACE" \
+    -scheme "$SCHEME" \
+    -destination "id=$DESTINATION_ID" \
+    -sdk iphonesimulator \
+    ${XCODE_OPTIONS[*]} \
+    build test \
+    2>&1 | xcpretty $XCPRETTY_FORMAT_OPTIONS
+fi
@@ -0,0 +1,22 @@
+#!/bin/bash -ex
+
+#
+# clean_externals
+# SwiftGit2
+#
+# Removes the outputs from the various static library targets.
+# Necessary when switching platforms/architectures as Xcode does not clean
+# these for you.
+#
+
+# A list of external static libraries included in the SwiftGit2 framework
+libraries=(
+    External/libgit2.a
+    External/libgit2-ios/libgit2-ios.a
+    External/libssh2-ios/lib/libssh2-ios.a
+    External/ios-openssl/lib/libssl.a
+    External/ios-openssl/lib/libcrypto.a
+    External/ios-openssl/include
+)
+
+rm -vrf "${libraries[@]}"
@@ -1,15 +1,13 @@
 #!/bin/bash

+# augment path to help it find cmake via homebrew
+PATH="/opt/homebrew/bin:/usr/local/bin:$PATH"
+
 SCRIPT_DIR=$(dirname "$0")
 source "${SCRIPT_DIR}/xcode_functions.sh"

 function setup_build_environment ()
 {
-    # augment path to help it find cmake installed in /usr/local/bin,
-    # e.g. via brew. Xcode's Run Script phase doesn't seem to honor
-    # ~/.MacOSX/environment.plist
-    PATH="/usr/local/bin:/opt/boxen/homebrew/bin:$PATH"
-    
    pushd "$SCRIPT_DIR/.." > /dev/null
    ROOT_PATH="$PWD"
    popd > /dev/null
@@ -22,7 +20,7 @@ function setup_build_environment ()
    MACOSX_DEPLOYMENT_TARGET=""

    XCODE_MAJOR_VERSION=$(xcode_major_version)
-    
+
    CAN_BUILD_64BIT="0"

    # If IPHONEOS_DEPLOYMENT_TARGET has not been specified
@@ -30,28 +28,30 @@ function setup_build_environment ()
    # directly (ie not from an Xcode proj)
    if [ -z "${IPHONEOS_DEPLOYMENT_TARGET}" ]
    then
-        IPHONEOS_DEPLOYMENT_TARGET="6.0"
+        IPHONEOS_DEPLOYMENT_TARGET="12.0"
    fi
-    
+
    # Determine if we can be building 64-bit binaries
    if [ "${XCODE_MAJOR_VERSION}" -ge "5" ] && [ $(echo ${IPHONEOS_DEPLOYMENT_TARGET} '>=' 6.0 | bc -l) == "1" ]
    then
        CAN_BUILD_64BIT="1"
    fi

-    ARCHS="i386 armv7 armv7s"
+    ARCHS=""
    if [ "${CAN_BUILD_64BIT}" -eq "1" ]
    then
        # For some stupid reason cmake needs simulator
        # builds to be first
        ARCHS="x86_64 ${ARCHS} arm64"
+    else
+        ARCHS="i386 ${ARCHS} armv7 armv7s"
    fi
 }

 function build_all_archs ()
 {
    setup_build_environment
-    
+
    local setup=$1
    local build_arch=$2
    local finish_build=$3
@@ -63,11 +63,15 @@ function build_all_archs ()

    for ARCH in ${ARCHS}
    do
-        if [ "${ARCH}" == "i386" ] || [ "${ARCH}" == "x86_64" ]
+        PLATFORMS=""
+        if [ "${ARCH}" == "i386" ] || [ "${ARCH}" == "x86_64" ] || [ "${ARCH}" == "arm64" ]
        then
-            PLATFORM="iphonesimulator"
-        else
-            PLATFORM="iphoneos"
+            PLATFORMS="${PLATFORMS} iphonesimulator"
+        fi
+
+        if [ "${ARCH}" == "arm64" ]
+        then
+            PLATFORMS="${PLATFORMS} iphoneos"
        fi

        SDKVERSION=$(ios_sdk_version)
@@ -79,17 +83,21 @@ function build_all_archs ()
            HOST="${ARCH}-apple-darwin"
        fi

-        SDKNAME="${PLATFORM}${SDKVERSION}"
-        SDKROOT="$(ios_sdk_path ${SDKNAME})"
-        
-        echo "Building ${LIBRARY_NAME} for ${SDKNAME} ${ARCH}"
-        echo "Please stand by..."
+        echo "Building ${ARCH} for ${PLATFORMS}"

-        # run the per arch build command
-        eval $build_arch
+        for PLATFORM in ${PLATFORMS}
+        do
+            SDKNAME="${PLATFORM}${SDKVERSION}"
+            SDKROOT="$(sdk_path ${SDKNAME})"
+
+            echo "Building ${LIBRARY_NAME} for ${SDKNAME} ${ARCH} on ${PLATFORM}"
+            echo "Please stand by..."
+
+            # run the per arch build command
+            eval $build_arch
+        done
    done

    # finish the build (usually lipo)
    eval $finish_build
 }
-
@@ -1,10 +0,0 @@
-BEGIN {
-    FS = "\n";
-}
-
-/Schemes:/ {
-    while (getline && $0 != "") {
-        sub(/^ +/, "");
-        print "'" $0 "'";
-    }
-}
@@ -1,12 +0,0 @@
-BEGIN {
-    FS = "\n";
-}
-
-/Targets:/ {
-    while (getline && $0 != "") {
-        if ($0 ~ /Tests/) continue;
-
-        sub(/^ +/, "");
-        print "'" $0 "'";
-    }
-}
@@ -1,34 +1,114 @@
-#!/bin/sh
+#!/bin/bash

 set -e

-# augment path to help it find cmake installed in /usr/local/bin,
-# e.g. via brew. Xcode's Run Script phase doesn't seem to honor
-# ~/.MacOSX/environment.plist
-PATH="/usr/local/bin:$PATH"
+# augment path to help it find cmake via homebrew
+PATH="/opt/homebrew/bin:/usr/local/bin:$PATH"

-if [ "External/libgit2.a" -nt "External/libgit2" ]
-then
-    echo "No update needed."
-    exit 0
-fi
+SCRIPT_DIR=$(dirname "$0")
+source "${SCRIPT_DIR}/xcode_functions.sh"

-cd "External/libgit2"
+function setup_build_environment ()
+{
+    pushd "$SCRIPT_DIR/.." > /dev/null
+    ROOT_PATH="$PWD"
+    popd > /dev/null

-if [ -d "build" ]; then
+    CLANG="/usr/bin/xcrun clang"
+    CC="${CLANG}"
+    CPP="${CLANG} -E"
+
+    MACOSX_DEPLOYMENT_TARGET="10.13"
+
+    XCODE_MAJOR_VERSION=$(xcode_major_version)
+    XCODE_MINOR_VERSION=$(xcode_minor_version)
+
+    if [ "${XCODE_MAJOR_VERSION}" -lt "14" ]
+    then
+        echo "Requires Xcode 14 or newer."
+        exit 1
+    fi
+
+    ARCHS="x86_64 arm64"
+}
+
+function setup ()
+{
+    if [ "${ROOT_PATH}/External/libgit2-mac/libgit2-mac.a" -nt "${ROOT_PATH}/External/libgit2" ]
+    then
+        echo "No update needed."
+        exit 0
+    fi
+
+    LIBRARY_NAME="libgit2"
+    LIB_PATH="${ROOT_PATH}/External/libgit2-mac"
+    rm -rf "${LIB_PATH}"
+
+    pushd "${ROOT_PATH}/External/libgit2" > /dev/null
+}
+
+function build_libgit2 ()
+{
    rm -rf "build"
-fi
+    mkdir "build"

-mkdir build
-cd build
+    pushd "build" > /dev/null

-cmake -DBUILD_SHARED_LIBS:BOOL=OFF -DBUILD_CLAR:BOOL=OFF -DTHREADSAFE:BOOL=ON ..
-cmake --build .
+    # install the each built arch somewhere sane
+    INSTALL_PREFIX="${LIB_PATH}/${SDKNAME}-${ARCH}.sdk"

-product="libgit2.a"
-install_path="../../${product}"
-if [ "${product}" -nt "${install_path}" ]; then
-    cp -v "${product}" "${install_path}"
-fi
+    mkdir -p "${INSTALL_PREFIX}"
+
+    LOG="${INSTALL_PREFIX}/build-libgit2.log"
+    echo "$LOG"
+
+    cmake \
+        -DBUILD_SHARED_LIBS:BOOL=OFF \
+        -DCMAKE_PREFIX_PATH:PATH="${ROOT_PATH}/External/libssh2-mac/bin/${SDKNAME}-${ARCH}.sdk" \
+        -DCMAKE_INSTALL_PREFIX:PATH="${INSTALL_PREFIX}/" \
+        -DBUILD_CLAR:BOOL=OFF \
+        -DTHREADSAFE:BOOL=ON \
+        -DCMAKE_OSX_ARCHITECTURES:STRING="${ARCH}" \
+        -DCMAKE_OSX_DEPLOYMENT_TARGET:STRING="${MACOSX_DEPLOYMENT_TARGET}" \
+        .. >> "${LOG}" 2>&1
+    cmake --build . --target install >> "${LOG}" 2>&1
+
+    # push the built library into the list
+    BUILT_LIB_PATHS+=("${INSTALL_PREFIX}/lib/libgit2.a")
+    popd > /dev/null
+}
+
+function fat_binary ()
+{
+    echo "Building fat binary..."
+
+    lipo -create "${BUILT_LIB_PATHS[@]}" -output "${ROOT_PATH}/External/libgit2-mac/libgit2-mac.a"
+
+    echo "Building done."
+
+    popd > /dev/null
+}
+
+setup_build_environment
+setup
+
+echo "Building for ${ARCHS}"
+
+for ARCH in ${ARCHS}
+do
+    PLATFORM="macosx"
+    SDKVERSION=$(macos_sdk_version)
+
+    SDKNAME="${PLATFORM}${SDKVERSION}"
+    SDKROOT="$(sdk_path ${SDKNAME})"
+
+    echo "Building ${LIBRARY_NAME} for ${SDKNAME} ${ARCH}"
+    echo "Please stand by..."
+
+    # run the per arch build command
+    build_libgit2
+done
+
+fat_binary

 echo "libgit2 has been updated."
@@ -8,7 +8,7 @@ source "${SCRIPT_DIR}/ios_build_functions.sh"

 function setup ()
 {
-    if [ "${ROOT_PATH}/External/libgit2-ios/libgit2-ios.a" -nt "${ROOT_PATH}/External/libgit2" ]
+    if [ "${ROOT_PATH}/External/libgit2-ios/libgit2.xcframework" -nt "${ROOT_PATH}/External/libgit2" ]
    then
        echo "No update needed."
        exit 0
@@ -42,20 +42,21 @@ function build_libgit2 ()
    LOG="${INSTALL_PREFIX}/build-libgit2.log"
    echo "$LOG"

-    cmake -DCMAKE_C_COMPILER=clang \
+    cmake \
        -DCMAKE_C_COMPILER_WORKS:BOOL=ON \
        -DBUILD_SHARED_LIBS:BOOL=OFF \
-        -DOPENSSL_INCLUDE_DIR:PATH=../../External/ios-openssl/include/ \
-        -DCMAKE_LIBRARY_PATH:PATH=../../External/libssh2-ios/lib/ \
-        -DCMAKE_INCLUDE_PATH:PATH=../../External/libssh2-ios/include/libssh2/ \
-        -DOPENSSL_SSL_LIBRARY:FILEPATH=../../External/ios-openssl/lib/libssl.a \
-        -DCMAKE_LIBRARY_PATH:PATH="${SDKROOT}/usr/lib/" \
-        -DOPENSSL_CRYPTO_LIBRARY:FILEPATH=../../External/ios-openssl/lib/libcrypto.a \
+        -DCMAKE_PREFIX_PATH:PATH="${ROOT_PATH}/External/libssh2-ios/bin/${SDKNAME}-${ARCH}.sdk" \
+        -DPKG_CONFIG_USE_CMAKE_PREFIX_PATH:BOOL=ON \
        -DCMAKE_INSTALL_PREFIX:PATH="${INSTALL_PREFIX}/" \
        -DBUILD_CLAR:BOOL=OFF \
+        -DBUILD_TESTS:BOOL=OFF \
+        -DREGEX_BACKEND:STRING="builtin" \
        -DTHREADSAFE:BOOL=ON \
+        -DCURL:BOOL=OFF \
+        -DCMAKE_C_FLAGS:STRING="-fembed-bitcode" \
        "${SYS_ROOT}" \
        -DCMAKE_OSX_ARCHITECTURES:STRING="${ARCH}" \
+        -DCMAKE_OSX_DEPLOYMENT_TARGET:STRING="${IPHONEOS_DEPLOYMENT_TARGET}" \
        .. >> "${LOG}" 2>&1
    cmake --build . --target install >> "${LOG}" 2>&1

@@ -66,13 +67,72 @@ function build_libgit2 ()

 function fat_binary ()
 {
-    echo "Building fat binary..."
+    echo "Building fat binary for simulator..."

-    lipo -create "${BUILT_LIB_PATHS[@]}" -output "${ROOT_PATH}/External/libgit2-ios/libgit2-ios.a"
+    # Collect all simulator build paths
+    for path in "${BUILT_LIB_PATHS[@]}"
+    do
+        case "$path" in
+            *libgit2-ios/iphonesimulator* )
+                SIMULATOR_LIB_PATHS+=("$path")
+                # Remember one header location (headers are the same, so overwriting doesn't matter)
+                base_dir=$(dirname $(dirname "${path}"))
+                HEADER_PATH="${base_dir}/include/git2.h"
+                ;;
+            * )
+                # Ignore libs build for the actual phone
+                ;;
+        esac
+    done
+
+    SIMULATOR_LIB_DIR="${ROOT_PATH}/External/libgit2-ios/iphonesimulator"
+    mkdir -p "${SIMULATOR_LIB_DIR}"
+
+    echo "... from ${SIMULATOR_LIB_PATHS[@]}"
+    lipo -create "${SIMULATOR_LIB_PATHS[@]}" -output "${SIMULATOR_LIB_DIR}/libgit2.a"
+
+    echo "Copying shared simulator header from ${HEADER_PATH}"
+    cp "${HEADER_PATH}" "${SIMULATOR_LIB_DIR}/libgit2.h"

    echo "Building done."
+}
+
+function xcframework ()
+{
+    echo "Building XCFramework..."
+
+    for path in "${BUILT_LIB_PATHS[@]}"
+    do
+        case "$path" in
+            *libgit2-ios/iphonesimulator* )
+                # Skip simulator library binaries
+                ;;
+            * )
+                args+=("-library" "${path}")
+                base_dir=$(dirname $(dirname "${path}"))
+                args+=("-headers" "${base_dir}/include/git2.h")
+                ;;
+        esac
+    done
+
+    args+=("-library" "${SIMULATOR_LIB_DIR}/libgit2.a")
+    args+=("-headers" "${SIMULATOR_LIB_DIR}/libgit2.h")
+
+    echo "... from ${args[@]}"
+    xcodebuild -create-xcframework \
+               "${args[@]}" \
+               -output "${ROOT_PATH}/External/libgit2-ios/libgit2.xcframework"
+
+    echo "Building done."
+}
+
+
+function combine_all_the_binaries ()
+{
+    fat_binary
+    xcframework

    popd > /dev/null
 }

-build_all_archs setup build_libgit2 fat_binary
+build_all_archs setup build_libgit2 combine_all_the_binaries
@@ -16,7 +16,7 @@ function setup ()
    LIBRARY_NAME="libssh2"
 }

-function build_ssh2 () 
+function build_ssh2 ()
 {
    mkdir -p "${ROOT_PATH}/External/libssh2-ios/lib" "${ROOT_PATH}/External/libssh2-ios/lib" "${ROOT_PATH}/External/libssh2-ios/src"

@@ -24,8 +24,8 @@ function build_ssh2 ()
    cp -R "${ROOT_PATH}/External/libssh2" "${ROOT_PATH}/External/libssh2-ios/src/"
    pushd "${ROOT_PATH}/External/libssh2-ios/src/libssh2" > /dev/null

-    export CFLAGS="-arch ${ARCH} -pipe -no-cpp-precomp -isysroot ${SDKROOT} -miphoneos-version-min=${IPHONEOS_DEPLOYMENT_TARGET}"
-    export CPPFLAGS="-arch ${ARCH} -pipe -no-cpp-precomp -isysroot ${SDKROOT} -miphoneos-version-min=${IPHONEOS_DEPLOYMENT_TARGET}"
+    export CFLAGS="-arch ${ARCH} -fembed-bitcode -pipe -no-cpp-precomp -isysroot ${SDKROOT} -miphoneos-version-min=${IPHONEOS_DEPLOYMENT_TARGET}"
+    export CPPFLAGS="-arch ${ARCH} -fembed-bitcode -pipe -no-cpp-precomp -isysroot ${SDKROOT} -miphoneos-version-min=${IPHONEOS_DEPLOYMENT_TARGET}"

    mkdir -p "${ROOT_PATH}/External/libssh2-ios/bin/${SDKNAME}-${ARCH}.sdk"
    LOG="${ROOT_PATH}/External/libssh2-ios/bin/${SDKNAME}-${ARCH}.sdk/build-libssh2.log"
@@ -47,7 +47,7 @@ function fat_binary ()

    lipo -create "${BUILT_LIBS[@]}" -output "${ROOT_PATH}/External/libssh2-ios/lib/libssh2-ios.a"
    mkdir -p "${ROOT_PATH}/External/libssh2-ios/include/libssh2"
-    cp -R "${ROOT_PATH}/External/libssh2-ios/bin/iphonesimulator${SDKVERSION}-i386.sdk/include/libssh2.h" "${ROOT_PATH}/External/libssh2-ios/include/libssh2/"
+    cp -R "${ROOT_PATH}/External/libssh2-ios/bin/iphonesimulator${SDKVERSION}-x86_64.sdk/include/libssh2.h" "${ROOT_PATH}/External/libssh2-ios/include/libssh2/"

    echo "Building done."
 }
@@ -43,7 +43,7 @@ function build_ssl ()
    echo "$LOG"

    ./Configure ${HOST} ${CONFIG} --openssldir="/tmp/openssl-${ARCH}" >> "${LOG}" 2>&1
-    perl -i -pe "s|^CC= gcc|CC= ${CLANG} -miphoneos-version-min=${IPHONEOS_DEPLOYMENT_TARGET} -arch ${ARCH} |g" Makefile >> "${LOG}" 2>&1
+    perl -i -pe "s|^CC= gcc|CC= ${CLANG} -miphoneos-version-min=${IPHONEOS_DEPLOYMENT_TARGET} -arch ${ARCH} -fembed-bitcode |g" Makefile >> "${LOG}" 2>&1
    perl -i -pe "s|^CFLAG= (.*)|CFLAG= -isysroot ${SDKROOT} \$1|g" Makefile >> "${LOG}" 2>&1
    make >> "${LOG}" 2>&1

@@ -14,17 +14,39 @@ function xcode_major_version ()
    xcode_version | awk -F '.' '{ print $1 }'
 }

-# Returns the latest iOS SDK version available
-# via xcodebuild
+function xcode_minor_version ()
+{
+    xcode_version | awk -F '.' '{ print $2 }'
+}
+
+# Returns the latest iOS SDK version available via xcodebuild.
 function ios_sdk_version ()
 {
-    # This relies on the fact that the latest iPhone SDK
-    # is the last thing listed before the Xcode version.
-    /usr/bin/xcodebuild -version -sdk 2> /dev/null | grep SDKVersion | tail -n 1 |  awk '{ print $2 }' 
+    # The grep command produces output like the following, singling out the
+    # SDKVersion of just the iPhone* SDKs:
+    #
+    #   iPhoneOS9.0.sdk - iOS 9.0 (iphoneos9.0)
+    #   SDKVersion: 9.0
+    #   --
+    #   iPhoneSimulator9.0.sdk - Simulator - iOS 9.0 (iphonesimulator9.0)
+    #   SDKVersion: 9.0
+
+    /usr/bin/xcodebuild -version -sdk 2> /dev/null | grep -A 1 '^iPhone' | tail -n 1 |  awk '{ print $2 }'
+}
+
+function macos_sdk_version ()
+{
+    # The grep command produces output like the following, singling out the
+    # SDKVersion of just the Mac SDKs:
+    #
+    #     MacOSX11.0.sdk - macOS 11.0 (macosx11.0)
+    #     SDKVersion: 11.0
+    #     ...
+    /usr/bin/xcodebuild -version -sdk 2> /dev/null | grep -A 1 '^MacOSX' | tail -n 1 |  awk '{ print $2 }'
 }

 # Returns the path to the specified iOS SDK name
-function ios_sdk_path ()
+function sdk_path ()
 {
    /usr/bin/xcodebuild -version -sdk 2> /dev/null | grep -i $1 | grep 'Path:' | awk '{ print $2 }'
 }
@@ -1,35 +0,0 @@
-# Exit statuses:
-#
-# 0 - No errors found.
-# 1 - Build or test failure. Errors will be logged automatically.
-# 2 - Untestable target. Retry with the "build" action.
-
-BEGIN {
-    status = 0;
-}
-
-{
-    print;
-    fflush(stdout);
-}
-
-/is not valid for Testing/ {
-    exit 2;
-}
-
-/[0-9]+: (error|warning):/ {
-    errors = errors $0 "\n";
-}
-
-/(TEST|BUILD) FAILED/ {
-    status = 1;
-}
-
-END {
-    if (length(errors) > 0) {
-        print "\n*** All errors:\n" errors;
-    }
-
-    fflush(stdout);
-    exit status;
-}
@@ -1,25 +0,0 @@
-# Exit statuses:
-#
-# 0 - No errors found.
-# 1 - Wrong SDK. Retry with SDK `iphonesimulator`.
-# 2 - Missing target.
-
-BEGIN {
-    status = 0;
-}
-
-{
-    print;
-}
-
-/Testing with the '(.+)' SDK is not yet supported/ {
-    status = 1;
-}
-
-/does not contain a target named/ {
-    status = 2;
-}
-
-END {
-    exit status;
-}