Support tracking dependencies by branch

In addition to `version` and all the features around that, we can also
explicitly track a remote `branch` that will be fetched/updated when
`modulo update` is run.

Author: dmiedema

ModuloKit/Actions.swift

@@ -22,8 +22,8 @@ open class Actions {
         }
     }
 
-    open func addDependency(_ url: String, version: SemverRange?, unmanaged: Bool) -> ErrorCode {
-        let dep = DependencySpec(repositoryURL: url, version: version)
+    open func addDependency(_ url: String, version: SemverRange?, branch: String?, unmanaged: Bool) -> ErrorCode {
+        let dep = DependencySpec(repositoryURL: url, version: version, branch: branch)
         if var workingSpec = ModuleSpec.workingSpec() {
             // does this dep already exist in here??
             if let _ = workingSpec.dependencyForURL(url) {
@@ -77,6 +77,16 @@ open class Actions {
                         exit(checkoutResult.errorMessage())
                     }
                 }
+                if let branch = dep.branch {
+                    let checkoutResult = scm.checkout(branch: branch, path: clonePath)
+                    if checkoutResult != .success {
+                        exit(checkoutResult.errorMessage())
+                    }
+                    let pullResult = scm.pull(clonePath, remoteData: nil)
+                    if pullResult != .success {
+                        exit(pullResult.errorMessage())
+                    }
+                }
 
                 // things worked, so add it to the approprate place in the overall state.
                 if explicit {
@@ -106,8 +116,13 @@ open class Actions {
                         if checkoutResult != .success {
                             exit(checkoutResult.errorMessage())
                         }
+                    } else if let branch = dep.branch {
+                        let checkoutResult = scm.checkout(branch: branch, path: clonePath)
+                        if checkoutResult != .success {
+                            exit(checkoutResult.errorMessage())
+                        }
                     } else {
-                        exit("\(dep.name()) doesn't have a version and isn't unmanaged, not sure what to do.")
+                        exit("\(dep.name()) doesn't have a version, branch, and isn't marked as 'unmanaged', not sure what to do.")
                     }
                 }
             }

ModuloKit/Commands/AddCommand.swift

@@ -16,6 +16,7 @@ import Foundation
 open class AddCommand: NSObject, Command {
     // internal properties
     fileprivate var version: SemverRange? = nil
+    fileprivate var branch: String? = nil
     fileprivate var repositoryURL: String! = nil
     fileprivate var shouldUpdate: Bool = false
     fileprivate var unmanaged: Bool = false
@@ -40,6 +41,12 @@ open class AddCommand: NSObject, Command {
                 self.version = SemverRange(value)
             }
         }
+
+        addOptionValue(["--branch"], usage: "specify the branch to track", valueSignature: "<branch>") { (option, value) in
+            if let value = value {
+                self.branch = value
+            }
+        }
 
         addOption(["--unmanaged"], usage: "specifies that this module will be unmanaged") { (option, value) in
             self.unmanaged = true
@@ -57,8 +64,8 @@ open class AddCommand: NSObject, Command {
     open func execute(_ otherParams: Array<String>?) -> Int {
         let actions = Actions()
 
-        if version == nil && unmanaged == false {
-            writeln(.stderr, "A version or range must be specified via --version, or --unmanaged must be used.")
+        if version == nil && branch == nil && unmanaged == false {
+            writeln(.stderr, "A version or range must be specified via --version, a branch must be specified via --branch, or --unmanaged must be used.")
             return ErrorCode.commandError.rawValue
         }
 
@@ -69,7 +76,7 @@ open class AddCommand: NSObject, Command {
             }
         }
 
-        let result = actions.addDependency(repositoryURL, version: version, unmanaged: unmanaged)
+        let result = actions.addDependency(repositoryURL, version: version, branch: branch, unmanaged: unmanaged)
         if result == .success {
             if shouldUpdate {
                 writeln(.stdout, "Added \(String(describing: repositoryURL)).")

ModuloKit/SCM/Git.swift

@@ -100,7 +100,7 @@ open class Git: SCM {
         let initialWorkingPath = FileManager.workingPath()
         FileManager.setWorkingPath(path)
 
-        let updateCommand = "git fetch --recurse-submodules --all --tags"
+        let updateCommand = "git fetch --recurse-submodules --all"
         let status = runCommand(updateCommand)
 
         FileManager.setWorkingPath(initialWorkingPath)
@@ -175,6 +175,54 @@ open class Git: SCM {
 
         return .success
     }
+
+    open func checkout(branch: String, path: String) -> SCMResult {
+        if !FileManager.fileExists(path) {
+            return .error(code: 1, message: "Module path '\(path)' does not exist.")
+        }
+
+        var checkoutCommand = ""
+
+        let initialWorkingPath = FileManager.workingPath()
+        FileManager.setWorkingPath(path)
+
+        let existingBranches = branches(".")
+
+        var neededFetch = false
+        var fetchResult: Int32? = nil
+        if !existingBranches.contains(branch) {
+            // try fetching it directly
+            fetchResult = runCommand("git fetch origin \(branch)")
+            neededFetch = true
+        }
+
+        checkoutCommand = "git checkout origin/\(branch) --quiet"
+
+        if neededFetch,
+            let fetchResult = fetchResult,
+            fetchResult != 0 {
+            if verbose {
+                writeln(.stderr, "Unable to find branch '\(branch)'.")
+            }
+            return .error(code: SCMDefaultError, message: "Unable to find a match for \(branch).")
+        }
+
+        let status = runCommand(checkoutCommand)
+
+        let submodulesResult = collectAnySubmodules()
+
+        FileManager.setWorkingPath(initialWorkingPath)
+
+        if status != 0 {
+            return .error(code: status, message: "Unable to checkout '\(branch)'.")
+        }
+
+        if submodulesResult != .success {
+            return submodulesResult
+        }
+
+        return .success
+    }
 
     open func adjustIgnoreFile(pattern: String, removing: Bool) -> SCMResult {
         let localModulesPath = State.instance.modulePathName

ModuloKit/SCM/SCM.swift

@@ -76,6 +76,7 @@ public protocol SCM {
     func fetch(_ path: String) -> SCMResult
     func pull(_ path: String, remoteData: String?) -> SCMResult
     func checkout(version: SemverRange, path: String) -> SCMResult
+    func checkout(branch: String, path: String) -> SCMResult
     func remove(_ path: String) -> SCMResult
     func adjustIgnoreFile(pattern: String, removing: Bool) -> SCMResult
     func checkStatus(_ path: String) -> SCMResult

ModuloKit/Specs/DependencySpec.swift

@@ -17,10 +17,12 @@ public struct DependencySpec {
     var repositoryURL: String
     // version or version range
     var version: SemverRange?
+    /// Branch to track
+    var branch: String?
 
     var unmanaged: Bool {
         get {
-            return (version == nil)
+            return (version == nil) && (branch == nil)
         }
     }
 }
@@ -29,7 +31,8 @@ extension DependencySpec: ELDecodable {
     public static func decode(_ json: JSON?) throws -> DependencySpec {
         return try DependencySpec(
             repositoryURL: json ==> "repositoryURL",
-            version: json ==> "version"
+            version: json ==> "version",
+            branch: json ==> "branch"
         )
     }
 
@@ -42,7 +45,8 @@ extension DependencySpec: ELEncodable {
     public func encode() throws -> JSON {
         return try encodeToJSON([
             "repositoryURL" <== repositoryURL,
-            "version" <== version
+            "version" <== version,
+            "branch" <== branch
         ])
     }
 }

ModuloKitTests/TestAdd.swift

@@ -78,4 +78,33 @@ class TestAdd: XCTestCase {
 
         FileManager.setWorkingPath("..")
     }
+
+    func testAddModuleByBranch() {
+        let status = Git().clone("[email protected]:modulo-dm/test-add.git", path: "test-add")
+        XCTAssertTrue(status == .success)
+
+        FileManager.setWorkingPath("test-add")
+
+        let repoURL = "[email protected]:modulo-dm/test-add-update.git"
+
+        let result = Modulo.run(["add", repoURL, "--branch", "master", "-v"])
+        XCTAssertTrue(result == .success)
+
+
+        guard let spec = ModuleSpec.load(contentsOfFile: specFilename) else {
+            XCTFail("Failed to get spec from file \(specFilename)")
+            return }
+        XCTAssertTrue(spec.dependencies.count > 0)
+        guard let dep = spec.dependencyForURL(repoURL) else {
+            XCTFail("Failed to find dependency for url \(repoURL) in spec \(spec)")
+            return }
+        XCTAssertNil(dep.version)
+        XCTAssertFalse(dep.unmanaged)
+        XCTAssertNotNil(dep.branch)
+        XCTAssertTrue(dep.branch == "master")
+
+        FileManager.setWorkingPath("..")
+
+        Git().remove("test-add")
+    }
 }

modulo.xcodeproj/xcshareddata/xcschemes/modulo.xcscheme

@@ -69,11 +69,11 @@
          </CommandLineArgument>
          <CommandLineArgument
             argument = "defaults --set --alwaysVerbose true"
-            isEnabled = "YES">
+            isEnabled = "NO">
          </CommandLineArgument>
          <CommandLineArgument
             argument = "update --verbose"
-            isEnabled = "NO">
+            isEnabled = "YES">
          </CommandLineArgument>
          <CommandLineArgument
             argument = "update"