Merge installation logic into swiftly as an init subcommand

DESIGN.md

@@ -19,19 +19,32 @@ This document contains the high level design of swiftly. Not all features have b
   - [Implementation sketch - macOS](#implementation-sketch---macos)
   - [`config.json` schema](#configjson-schema)
 
-## Linux
+## Installation of swiftly
+
+The installation of swiftly is divided into two phases: delivery and initialization. Delivery of the swiftly binary can be accomplished using different methods:
+
+* Shell "one-liner" with a string of commands that can be copy/pasted into the user's shell to securely download from the trusted website and proceed to initialization
+* Direct download from a trusted website with guidance on the correct binary for the user's platform to download and then how move on to initialization
+* System-level package (e.g. homebrew, pkg, apt-get, rpm) that downloads and places the swiftly binary in a system location outside of the user's home directory, often runnable from the user's path
+* Manual compilation of the swiftly binary from this git repository (e.g. from a development environment)
+
+We'll need an initialization phase, which detects information about the OS and distribution in the case of Linux. The initialization mode is also responsible for setting up the directory structure for the toolchains (if necessary), setting up the shell environment for the user, and determining any operating system level dependencies that are required, but missing. Swiftly has its own configuration stored in the form of a `config.json` file, which will be created as part of initialization. None of the delivery methods can perform all of these steps on their own. System package managers don't normally update all users' environment or update the user's home directory structure directly.
 
-### Installation of swiftly
+Swiftly can perform these tasks itself with the capabilities provided by the Swift language and libraries, such as rich argument parsing, and launching system processes provided that the binary is delivered to the user. The trigger for the initialization is done via an `init` subcommand with some initialization detection for the other subcommands to help guide users who have gone off track.
+
+```
+swiftly init
+```
 
-We'll need a bootstrapping script which detects information about the OS and downloads the correct pre-built swiftly executable. We can use [rustup-init.sh](https://github.com/rust-lang/rustup/blob/master/rustup-init.sh) as a general guide on implementing such a script, though it is more complicated and supports far more systems than I think we need to. At least for the initial release, I think we'll only need to support the platforms listed on [Swift.org - Getting Started](http://swift.org/getting-started), namely:
-- Ubuntu 16.04
-- Ubuntu 18.04
-- Ubuntu 20.04
-- CentOS 7
-- CentOS 8
-- Amazon Linux 2
+Also, the swiftly binary itself is copied into this location if it is not run from a system location, managed by a system package manager. In this case the user is notified that a copy of swiftly has been made in the swiftly bin directory (where the symlinks to the toolchain commands will be managed) so that they can remove the temporary copy that they used to initialize.
 
-Once it has detected which platform the user is running, the script will then create `$HOME/.local/share/swiftly` (or a different path, if the user provides one. For an initial MVP, I think we can always install there). It'll also create `$HOME/.local/bin` if needed, download the prebuilt swiftly executable appropriate for the platform, and drop it in there.
+## Swiftly upgrade
+
+As part of swiftly's regular operations it can detect that the current configuration is out of date and error out. The `config.json` file contains a version at the moment it was created or last upgraded. In the case of an older version it will direct the user to run init to perform the upgrade. If a downgrade situation is detected then swiflty will fail with an error.
+
+There is also a self-update mechanism that will automate the delivery of the new swiftly binary, verifies it and runs the init subcommand to initiate the upgrade procedure. Note that the self-update will error out without performing any operations if swiftly is installed in the system, outside of the user's home directory.
+
+## Linux
 
 ### Installation of a Swift toolchain
 
@@ -52,11 +65,6 @@ The `~/.local/bin` directory would include symlinks pointing to the `bin` direct
 This is all very similar to how rustup does things, but I figure there's no need to reinvent the wheel here.
 
 ## macOS
-### Installation of swiftly
-
-Similar to Linux, the bootstrapping script for macOS will create a `~/.swiftly/bin` directory and drop the swiftly executable in it. A similar `~/.swiftly/env` file will be created and a message will be printed suggesting users add source `~/.swiftly/env` to their `.bash_profile` or `.zshrc`.
-
-The bootstrapping script will detect if xcode is installed and prompt the user to install it if it isn’t. We could also ask the user if they’d like us to install the xcode command line tools for them via `xcode-select --install`.
 
 ### Installation of a Swift toolchain
 

Sources/SwiftlyCore/SwiftlyCore.swift

@@ -1,6 +1,6 @@
 import Foundation
 
-public let version = SwiftlyVersion(major: 0, minor: 3, patch: 0)
+public let version = SwiftlyVersion(major: 0, minor: 4, patch: 0, suffix: "dev")
 
 /// A separate home directory to use for testing purposes. This overrides swiftly's default
 /// home directory location logic.

Sources/SwiftlyCore/SwiftlyVersion.swift

@@ -3,9 +3,9 @@ import Foundation
 
 /// Struct modeling a version of swiftly itself.
 public struct SwiftlyVersion: Equatable, Comparable, CustomStringConvertible {
-    /// Regex matching versions like "a.b.c", "a.b.c-alpha", and "a.b.c-alpha2".
+    /// Regex matching versions like "a.b.c", "a.b.c-alpha", and "a.b.c-alpha.2".
     static let regex: Regex<(Substring, Substring, Substring, Substring, Substring?)> =
-        try! Regex("^(\\d+)\\.(\\d+)\\.(\\d+)(?:-([a-zA-Z0-9]+))?$")
+        try! Regex("^(\\d+)\\.(\\d+)\\.(\\d+)(?:-([a-zA-Z0-9\\.]+))?$")
 
     public let major: Int
     public let minor: Int

Tests/SwiftlyTests/SwiftlyVersionTests.swift

@@ -0,0 +1,68 @@
+import Foundation
+import SwiftlyCore
+import XCTest
+
+final class SwiftlyVersionTests: SwiftlyTests {
+    func testSanity() throws {
+        // GIVEN: a simple valid swiftly version string with major, minor, and patch
+        let vs = "0.3.0"
+        // WHEN: that version is parsed
+        let ver = try! SwiftlyVersion(parsing: vs)
+        // THEN: it succeeds and the major, minor, and patch parts match
+        XCTAssertEqual(0, ver.major)
+        XCTAssertEqual(3, ver.minor)
+        XCTAssertEqual(0, ver.patch)
+        XCTAssertEqual(nil, ver.suffix)
+
+        // GIVEN: two different swiftly versions
+        let vs040 = "0.4.0"
+        let ver040 = try! SwiftlyVersion(parsing: vs040)
+        // WHEN: the versions are compared
+        let cmp = ver040 > ver
+        // THEN: the comparison highlights the larger version
+        XCTAssertTrue(cmp)
+    }
+
+    func testPreRelease() throws {
+        // GIVEN: a swiftly version string with major, minor, patch, and suffix (pre-release)
+        let preRelease = "0.4.0-dev"
+        // WHEN: that version is parsed
+        let preVer = try! SwiftlyVersion(parsing: preRelease)
+        // THEN: it succeeds and the major, minor, patch, and suffix parts match
+        XCTAssertEqual(0, preVer.major)
+        XCTAssertEqual(4, preVer.minor)
+        XCTAssertEqual(0, preVer.patch)
+        XCTAssertEqual("dev", preVer.suffix)
+
+        // GIVEN: a swiftly pre release version and the final release version
+        let releaseVer = try! SwiftlyVersion(parsing: "0.4.0")
+        // WHEN: the versions are compared
+        let cmp = releaseVer > preVer
+        // THEN: the released version is consider larger
+        XCTAssertTrue(cmp)
+
+        // GIVEN: a swiftly pre release version and the previous release
+        let oldReleaseVer = try! SwiftlyVersion(parsing: "0.3.0")
+        // WHEN: the versions are compared
+        let cmpOldRelease = oldReleaseVer < preVer
+        // THEN: the older version is considered smaller than the pre release
+        XCTAssertTrue(cmpOldRelease)
+
+        // GIVEN: two pre release versions that are identical except for their suffix
+        let preVer2 = try! SwiftlyVersion(parsing: "0.4.0-pre")
+        // WHEN: the versions are compared
+        let cmpPreVers = preVer2 > preVer
+        // THEN: the lexicographically larger one is considered larger
+        XCTAssertTrue(cmpPreVers)
+
+        // GIVEN: a pre-release version with dots in it
+        let preReleaseDot = "1.5.0-alpha.1"
+        // WHEN: that version is parsed
+        let preVerDot = try! SwiftlyVersion(parsing: preReleaseDot)
+        // THEN: it succeeds and the major, minor, patch, and suffix parts match
+        XCTAssertEqual(1, preVerDot.major)
+        XCTAssertEqual(5, preVerDot.minor)
+        XCTAssertEqual(0, preVerDot.patch)
+        XCTAssertEqual("alpha.1", preVerDot.suffix)
+    }
+}