Initial commit

Author: mattt

.gitignore

@@ -0,0 +1,6 @@
+.DS_Store
+/.build
+/Packages
+/*.xcodeproj
+xcuserdata/
+.swiftpm

LICENSE.md

@@ -0,0 +1,19 @@
+Copyright 2020 Read Evaluate Press, LLC
+
+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.

Package.swift

@@ -0,0 +1,30 @@
+// swift-tools-version:5.2
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "Git",
+    products: [
+        // Products define the executables and libraries produced by a package, and make them visible to other packages.
+        .library(
+            name: "Git",
+            targets: ["Git"]),
+    ],
+    dependencies: [
+        // Dependencies declare other packages that this package depends on.
+        // .package(url: /* package url */, from: "1.0.0"),
+    ],
+    targets: [
+        .systemLibrary(name: "Clibgit2", pkgConfig: "libgit2", providers: [
+            .brew(["libgit2"]),
+            .apt(["libgit2"])
+        ]),
+        .target(
+            name: "Git",
+            dependencies: ["Clibgit2"]),
+        .testTarget(
+            name: "GitTests",
+            dependencies: ["Git"]),
+    ]
+)

README.md

@@ -0,0 +1,19 @@
+# Git
+
+A package for working with Git repositories in Swift,
+built on top of [libgit2](https://libgit2.org).
+
+> **Warning**:
+> This is currently a work-in-progress and shouldn't be used in production.
+
+## Requirements
+
+- Swift 5.2
+
+## License
+
+MIT
+
+## Contact
+
+Mattt ([@mattt](https://twitter.com/mattt))

Sources/Clibgit2/module.modulemap

@@ -0,0 +1,5 @@
+module Clibgit2 [system] {
+  umbrella header "/usr/local/include/git2.h"
+  link "git2"
+  export *
+}

Sources/Git/Error.swift

@@ -0,0 +1,36 @@
+import Clibgit2
+
+/// A libgit error.
+public struct Error: Swift.Error {
+
+    /**
+     The error code.
+
+     Error codes correspond to `git_error_code` constants, like `GIT_ENOTFOUND`.
+     */
+    public let code: Int // TODO: import raw values declared by libgit2
+
+
+    /// The error message, if any.
+    public let message: String?
+
+    private static var lastErrorMessage: String? {
+        guard let error = giterr_last() else { return nil }
+        return String(cString: error.pointee.message)
+    }
+
+    init<Code: FixedWidthInteger>(code: Code, message: String? = Error.lastErrorMessage) {
+        self.code = Int(code)
+        self.message = message
+    }
+}
+
+// MARK: -
+
+func wrap(_ fn: () -> Int32) throws {
+    _ = initializer // FIXME
+    let result = fn()
+    guard result == 0 else {
+        throw Error(code: result)
+    }
+}

Sources/Git/Git.swift

@@ -0,0 +1,6 @@
+import Clibgit2
+
+let initializer: () = {
+    git_libgit2_init()
+}()
+

Sources/Git/Index.swift

@@ -0,0 +1,161 @@
+import Clibgit2
+import Foundation
+
+/// A repository index.
+public final class Index {
+    private(set) var pointer: OpaquePointer!
+
+    private var managed: Bool = false
+
+    init(_ pointer: OpaquePointer) {
+        self.pointer = pointer
+    }
+
+    deinit {
+        guard managed else { return }
+        git_index_free(pointer)
+    }
+
+    // MARK: -
+
+    /// The repository for the index.
+    public var owner: Repository {
+        return Repository(git_index_owner(pointer))
+    }
+
+    /// The file path to the repository index file.
+    public var path: String! {
+        return String(validatingUTF8: git_index_path(pointer))
+    }
+
+    /**
+     Update the contents of an existing index object in memory
+     by reading from disk.
+
+     - Important: If there are changes on disk,
+                  unwritten in-memory changes are discarded.
+
+     - Parameters:
+        - force: If true, this performs a "hard" read
+                 that discards in-memory changes
+                 and always reloads the on-disk index data.
+                 If there is no on-disk version,
+                 the index will be cleared.
+                 If false,
+                 this does a "soft" read that reloads the index data from disk
+                 only if it has changed since the last time it was loaded.
+                 Purely in-memory index data will be untouched.
+     */
+    public func reload(force: Bool) throws {
+        try wrap { git_index_read(pointer, force ? 1 : 0)}
+    }
+
+    /**
+     The index on-disk version.
+
+     Valid return values are 2, 3, or 4.
+     If 3 is returned, an index with version 2 may be written instead,
+     if the extension data in version 3 is not necessary.
+     */
+    public var version: Int {
+        return Int(git_index_version(pointer))
+    }
+}
+
+// MARK: -
+
+extension Index {
+    /// An entry in the index.
+    public final class Entry: Equatable, Comparable, Hashable {
+        weak var index: Index?
+        private(set) var rawValue: git_index_entry
+
+        init(rawValue: git_index_entry) {
+            self.rawValue = rawValue
+        }
+
+        /// The file path of the index entry.
+        public var path: String {
+            return String(validatingUTF8: rawValue.path)!
+        }
+
+        /// The size of the index entry.
+        public var fileSize: Int {
+            return Int(rawValue.file_size)
+        }
+
+        /// The creation time of the index entry.
+        public var creationTime: Date {
+            return Date(timeIntervalSince1970: TimeInterval(rawValue.ctime.seconds))
+        }
+
+        /// The modification time of the index entry
+        public var modificationTime: Date {
+            return Date(timeIntervalSince1970: TimeInterval(rawValue.mtime.seconds))
+        }
+
+        /// The blob object for the index entry, if any.
+        public var blob: Blob? {
+            let id = Object.ID(rawValue: rawValue.id)
+            return try? index?.owner.lookup(id)
+        }
+
+        // MARK: - Equatable
+
+        public static func == (lhs: Index.Entry, rhs: Index.Entry) -> Bool {
+            var loid = lhs.rawValue.id, roid = rhs.rawValue.id
+            return git_oid_cmp(&loid, &roid) == 0
+        }
+
+        // MARK: - Comparable
+
+        public static func < (lhs: Index.Entry, rhs: Index.Entry) -> Bool {
+            return lhs.path < rhs.path
+        }
+
+        // MARK: - Hashable
+
+        public func hash(into hasher: inout Hasher) {
+            hasher.combine(rawValue.uid)
+        }
+    }
+
+    final class Entries: Sequence, IteratorProtocol {
+        private weak var index: Index?
+        private(set) var pointer: OpaquePointer!
+
+        init(_ index: Index) throws {
+            try wrap { git_index_iterator_new(&pointer, index.pointer) }
+            self.index = index
+        }
+
+        deinit {
+            git_index_iterator_free(pointer)
+        }
+
+        var underestimatedCount: Int {
+            guard let index = index else { return 0 }
+            return git_index_entrycount(index.pointer)
+        }
+
+        // MARK: - Sequence
+
+        func next() -> Entry? {
+            do {
+                var pointer: UnsafePointer<git_index_entry>?
+                try wrap { git_index_iterator_next(&pointer, self.pointer) }
+                let entry = Entry(rawValue: pointer!.pointee)
+                entry.index = index
+                return entry
+            } catch {
+                return nil
+            }
+        }
+    }
+
+    /// Returns a sequence of entries in the index.
+    public var entries: AnySequence<Entry> {
+        guard let entries = try? Entries(self) else { return AnySequence(EmptyCollection()) }
+        return AnySequence(entries)
+    }
+}