update CLI

Author: yonaskolb

Package.resolved

@@ -16,6 +16,7 @@ let package = Package(
         .package(url: "https://github.com/kylef/PathKit.git", from: "0.8.0"),
         .package(url: "https://github.com/JohnSundell/ShellOut.git", from: "1.2.0"),
         .package(url: "https://github.com/onevcat/Rainbow.git", from: "2.1.0"),
+        .package(url: "https://github.com/nsomar/Guaka.git", from: "0.1.3"),
         ],
     targets: [
         // Targets are the basic building blocks of a package. A target can define a module or a test suite.
@@ -25,6 +26,7 @@ let package = Package(
             dependencies: [
                 "MintKit",
                 "Rainbow",
+                "Guaka",
                 ]),
         .target(
             name: "MintKit",

Package.swift

@@ -57,31 +57,47 @@ And then import wherever needed: `import MintKit`
 
 ## Usage
 
-Mint has 2 commands, `run` and `install`.
+Run `mint` to see usage instructions.
 
-#### Install
-This will checkout, build and copy a specific build by git tag
+```
+$ mint
+Usage:
+  mint [command]
+
+Available Commands:
+  install  Install a package
+  run      Run a package
+  update   Update a package
+  
+Use "mint [command] --help" for more information about a command.
+```
 
-#### Run
-Run will run a certain tool from the package. If it's not installed, it will install it first
+- **Install**: Installs a package. If it is already installed this won't do anything
+- **Run**: Runs a package. This will install if first if it doesn't exist
+- **Update**: Installs a package while enforcing an update and rebuild. Shouldn't be required unless you are pointing at a branch and want to update.
 
-#### Options
+These 3 commands use the same flags. They must all be followed by a repo name.
+This can be a shorthand for a github repo `install realm/SwiftLint` or a fully qualified git path `install https://github.com/realm/SwiftLint.git`.
 
-Each command is followed by git path, version and tool name. Anything after that in `run` will be passed to the command line tool. 
+##### Repo
+In the case of `run` you can also just pass the name of the repo if it is already installed `run swiftlint`. This will do a lookup of all installed packages.
 
-Git path can take the form:
+#### Version
+By default the version that is used is the latest git tag (or master if no tags exist). You can pass a specific version with the version flag (-v, --version) eg. `--version 1.2.0`
 
-- `yonaskolb/xcodegen` (github repo name)
-- `github.com/yonaskolb/xcodegen` (github repo)
-- `http://github.com/yonaskolb/xcodegen.git` (any full git path)
+#### Name
+By default the tool name will be the last path in the repo (so for `realm/swiftlint` it will be `swiftlint`). If there are any packages that have a different executable name when build you can specify it with `--name`
 
-The first 2 examples would be transformed into the last
+#### Arguments
+To pass in arguments to the final tool on `run` you need to use `--args="any arguments"`
 
+#### Examples
 ```
-$ mint run yonaskolb/xcodegen 1.2.0 xcodegen
+$ mint install yonaskolb/xcodegen 1.2.0 --args="--spec my_spec.yml"
+$ mint install yonaskolb/xcodegen
+$ mint run xcodegen
 ```
 
-
 ## Package.resources
 As the Swift Packager doesn't yet have a way of specifying resources directories, Mint looks for a custom `Package.resources` file in the repo. This is a plain text file that lists the resources directories on different lines:
 

README.md

@@ -2,15 +2,81 @@ import MintKit
 import Rainbow
 import Foundation
 import ShellOut
+import Guaka
 
-do {
-    try Mint.execute()
-} catch {
-    if let error = error as? ShellOutError {
-        let message = "Error: \(error.message)".red
-        print("🌱  \(message)\n\(error.output)")
-    } else {
-        print("🌱  Error: \(error)".red)
+func catchError(closure: () throws -> ()) {
+    do {
+        try closure()
+    } catch {
+        if let error = error as? ShellOutError {
+            if !error.message.isEmpty {
+                print(error.message.red)
+            }
+            if !error.output.isEmpty {
+                print(error.output)
+            }
+        } else {
+            print("🌱  Error: \(error)".red)
+        }
+        exit(1)
     }
-    exit(1)
 }
+
+let command = Command(usage: "mint")
+command.run = { _, _  in
+    print(command.helpMessage)
+}
+
+let repoHelp = "You must pass a repo either in the shorthand for of a github repo \"githubName/repo\", or a fully qualified .git path.\nAn optional version can be passed, otherwise the newest tag or master will be used"
+let versionFlag = Flag(shortName: "v", longName: "version", type: String.self, description: "The version to use. Usually this is a tag, but can also be a branch. If left out will use the latest tag or master")
+
+let nameFlag = Flag(shortName: "n", longName: "name", type: String.self, description: "The command to run")
+
+let argsFlag = Flag(shortName: "a", longName: "args", type: String.self, description: "the arguments to pass to the command being run")
+
+let runCommand = Command(usage: "run repo (version)", shortMessage: "Run a package", longMessage: "This will run a package tool. If it isn't installed if will do so first.\n\(repoHelp)", flags: [nameFlag, argsFlag], example: "mint run realm/swiftlint 0.22.0") { flags, args in
+    guard let repo = args.first else {
+        print("repo required".red)
+        return
+    }
+    let version = args.count >= 2 ? args[1] : ""
+    let name = flags.getString(name: "name")
+    let arguments = flags.getString(name: "args")
+    catchError {
+        try Mint.run(repo: repo, version: version, name: name, arguments: arguments)
+    }
+}
+
+let installCommand = Command(usage: "install repo (version)", shortMessage: "Install a package", longMessage: "This will install a package. If it's already installed no action will be taken.\n\(repoHelp)", flags: [nameFlag], example: "mint install realm/swiftlint 0.22.0") { flags, args in
+    guard let repo = args.first else {
+        print("repo required".red)
+        return
+    }
+    let version = args.count >= 2 ? args[1] : ""
+    let name = flags.getString(name: "name")
+    catchError {
+        try Mint.install(repo: repo, version: version, name: name, force: false)
+    }
+}
+
+let updateCommand = Command(usage: "update repo (version)", shortMessage: "Update a package", longMessage: "This will update a package even if it's already installed.\n\(repoHelp)", flags: [nameFlag], example: "mint install realm/swiftlint 0.22.0") { flags, args in
+    guard let repo = args.first else {
+        print("repo required".red)
+        return
+    }
+    let version = args.count >= 2 ? args[1] : ""
+    let name = flags.getString(name: "name")
+    catchError {
+        try Mint.install(repo: repo, version: version, name: name, force: true)
+    }
+}
+
+let bootstrapCommand = Command(usage: "bootstrap") { flags, args in
+
+}
+command.add(subCommand: runCommand)
+command.add(subCommand: installCommand)
+//command.add(subCommand: bootstrapCommand)
+
+command.execute()
+