♻️ Rework various common classes

phpmon-common/Core/Actions.swift

@@ -0,0 +1,202 @@
+//
+//  Services.swift
+//  PHP Monitor
+//
+//  Copyright © 2021 Nico Verbruggen. All rights reserved.
+//
+
+import Foundation
+import AppKit
+
+class Actions {
+    
+    // MARK: - Services
+    
+    public static func restartPhpFpm()
+    {
+        brew("services restart \(PhpSwitcher.phpInstall.formula)", sudo: true)
+    }
+    
+    public static func restartNginx()
+    {
+        brew("services restart nginx", sudo: true)
+    }
+    
+    public static func restartDnsMasq()
+    {
+        brew("services restart dnsmasq", sudo: true)
+    }
+    
+    public static func stopAllServices()
+    {
+        brew("services stop \(PhpSwitcher.phpInstall.formula)", sudo: true)
+        brew("services stop nginx", sudo: true)
+        brew("services stop dnsmasq", sudo: true)
+    }
+    
+    /**
+     Kindly asks Valet to switch to a specific PHP version.
+     */
+    public static func switchToPhpVersionUsingValet(
+        version: String,
+        availableVersions: [String],
+        completed: @escaping () -> Void
+    ) {
+        print("Switching to \(version) using Valet")
+        print(valet("use php@\(version)"))
+        completed()
+    }
+    
+    /**
+     Switching to a new PHP version involves:
+     - unlinking the current version
+     - stopping the active services
+     - linking the new desired version
+     
+     Please note that depending on which version is installed,
+     the version that is switched to may or may not be identical to `php` (without @version).
+     */
+    public static func switchToPhpVersion(
+        version: String,
+        availableVersions: [String],
+        completed: @escaping () -> Void
+    ) {
+        print("Switching to \(version), unlinking all versions...")
+
+        let group = DispatchGroup()
+        
+        availableVersions.forEach { (available) in
+            group.enter()
+            
+            DispatchQueue.global(qos: .userInitiated).async {
+                let formula = (available == PhpSwitcher.brewPhpVersion)
+                    ? "php" : "php@\(available)"
+                
+                brew("unlink \(formula)")
+                brew("services stop \(formula)", sudo: true)
+                
+                group.leave()
+            }
+        }
+        
+        group.notify(queue: .global(qos: .userInitiated)) {
+            print("All versions have been unlinked!")
+            print("Linking the new version!")
+            
+            let formula = (version == PhpSwitcher.brewPhpVersion) ? "php" : "php@\(version)"
+            brew("link \(formula) --overwrite --force")
+            brew("services start \(formula)", sudo: true)
+            
+            print("The new version has been linked!")
+            completed()
+        }
+    }
+    
+    // MARK: - Finding Config Files
+    
+    public static func openGenericPhpConfigFolder()
+    {
+        let files = [NSURL(fileURLWithPath: "\(Paths.etcPath)/php")];
+        NSWorkspace.shared.activateFileViewerSelecting(files as [URL])
+    }
+    
+    public static func openGlobalComposerFolder()
+    {
+        let file = FileManager.default.homeDirectoryForCurrentUser
+            .appendingPathComponent(".composer/composer.json")
+        NSWorkspace.shared.activateFileViewerSelecting([file] as [URL])
+    }
+    
+    public static func openPhpConfigFolder(version: String)
+    {
+        let files = [NSURL(fileURLWithPath: "\(Paths.etcPath)/php/\(version)/php.ini")];
+        NSWorkspace.shared.activateFileViewerSelecting(files as [URL])
+    }
+    
+    public static func openValetConfigFolder()
+    {
+        let file = FileManager.default.homeDirectoryForCurrentUser
+            .appendingPathComponent(".config/valet")
+        NSWorkspace.shared.activateFileViewerSelecting([file] as [URL])
+    }
+    
+    // MARK: - Quick Fix
+    
+    /**
+     Detects all currently available PHP versions,
+     and unlinks each and every one of them.
+     
+     After this, the brew services are also stopped,
+     the latest PHP version is linked, and php + nginx are restarted.
+     
+     If this does not solve the issue, the user may need to install additional
+     extensions and/or run `composer global update`.
+     */
+    public static func fixMyPhp()
+    {
+        brew("services restart dnsmasq", sudo: true)
+        
+        PhpSwitcher.shared.detectPhpVersions().forEach { (version) in
+            let formula = (version == PhpSwitcher.brewPhpVersion) ? "php" : "php@\(version)"
+            brew("unlink php@\(version)")
+            brew("services stop \(formula)")
+            brew("services stop \(formula)", sudo: true)
+        }
+        
+        brew("services stop php")
+        brew("services stop nginx")
+        brew("link php")
+        brew("services restart dnsmasq", sudo: true)
+        brew("services stop php", sudo: true)
+        brew("services stop nginx", sudo: true)
+    }
+    
+    // MARK: Common Shell Commands
+    
+    /**
+     Runs a `valet` command.
+     */
+    public static func valet(_ command: String) -> String
+    {
+        return Shell.pipe("sudo \(Paths.valet) \(command)", requiresPath: true)
+    }
+    
+    /**
+     Runs a `brew` command. Can run as superuser.
+     */
+    public static func brew(_ command: String, sudo: Bool = false)
+    {
+        Shell.run("\(sudo ? "sudo " : "")" + "\(Paths.brew) \(command)")
+    }
+    
+    /**
+     Runs `sed` in order to replace all occurrences of a string in a specific file with another.
+     */
+    public static func sed(file: String, original: String, replacement: String)
+    {
+        // Escape slashes (or `sed` won't work)
+        let e_original = original.replacingOccurrences(of: "/", with: "\\/")
+        let e_replacement = replacement.replacingOccurrences(of: "/", with: "\\/")
+        
+        // Check if gsed exists; it is able to follow symlinks,
+        // which we want to do to toggle the extension
+        if Shell.fileExists("\(Paths.binPath)/gsed") {
+            Shell.run("\(Paths.binPath)/gsed -i --follow-symlinks 's/\(e_original)/\(e_replacement)/g' \(file)")
+        } else {
+            Shell.run("sed -i '' 's/\(e_original)/\(e_replacement)/g' \(file)")
+        }
+    }
+    
+    /**
+     Uses `grep` to determine whether a particular query string can be found in a particular file.
+     */
+    public static func grepContains(file: String, query: String) -> Bool
+    {
+        return Shell.pipe("""
+            grep -q '\(query)' \(file); [ $? -eq 0 ] && echo "YES" || echo "NO"
+            """)
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .contains("YES")
+    }
+    
+}

phpmon-common/Core/Command.swift

@@ -0,0 +1,40 @@
+//
+//  Command.swift
+//  PHP Monitor
+//
+//  Copyright © 2021 Nico Verbruggen. All rights reserved.
+//
+
+import Cocoa
+
+public class Command {
+    
+    /**
+     Immediately executes a command.
+     
+     - Parameter path: The path of the command or program to invoke.
+     - Parameter arguments: A list of arguments that are passed on.
+     - Parameter trimNewlines: Removes empty new line output.
+     */
+    public static func execute(path: String, arguments: [String], trimNewlines: Bool = false) -> String {
+        let task = Process()
+        task.launchPath = path
+        task.arguments = arguments
+        
+        let pipe = Pipe()
+        task.standardOutput = pipe
+        task.launch()
+        
+        let data = pipe.fileHandleForReading.readDataToEndOfFile()
+        let output: String = String.init(data: data, encoding: String.Encoding.utf8)!
+        
+        if (trimNewlines) {
+            return output.components(separatedBy: .newlines)
+                .filter({ !$0.isEmpty })
+                .joined(separator: "\n")
+        }
+        
+        return output
+    }
+    
+}

phpmon-common/Core/Constants.swift

@@ -0,0 +1,56 @@
+//
+//  Constants.swift
+//  PHP Monitor
+//
+//  Copyright © 2021 Nico Verbruggen. All rights reserved.
+//
+
+import Cocoa
+
+class Constants {
+    
+    /**
+     * The latest PHP version that is considered to be stable at the time of release.
+     * This version number is currently not used (only as a default fallback).
+     */
+    static let LatestStablePhpVersion = "8.1"
+    
+    /**
+     The minimum version of Valet that is recommended.
+     If the installed version is older, a notification will be shown
+     every time the app launches (with a recommendation to upgrade).
+     
+     The minimum requirement is currently synced to PHP 8.1 compatibility.
+     See also: https://github.com/laravel/valet/releases/tag/v2.16.2
+     */
+    static let MinimumRecommendedValetVersion = "2.16.2"
+    
+    /**
+     * The PHP versions supported by this application.
+     * Versions that do not appear in this array are omitted from the list.
+     */
+    static let SupportedPhpVersions = [
+        // ====================
+        // STABLE RELEASES
+        // ====================
+        // Versions of PHP that are stable and are supported.
+        "5.6",
+        "7.0",
+        "7.1",
+        "7.2",
+        "7.3",
+        "7.4",
+        "8.0",
+        "8.1",
+        
+        // ====================
+        // EXPERIMENTAL SUPPORT
+        // ====================
+        // Every release that supports the next release will always support the next
+        // dev release. In this case, that means that the version below is detected.
+        "8.2"
+    ]
+    
+
+    
+}

phpmon-common/Core/Paths.swift

@@ -0,0 +1,67 @@
+//
+//  Paths.swift
+//  PHP Monitor
+//
+//  Copyright © 2021 Nico Verbruggen. All rights reserved.
+//
+
+import Foundation
+
+/**
+ The `Paths` class is used to locate various binaries on the system,
+ and provides a full
+ */
+public class Paths {
+    
+    public static let shared = Paths()
+    
+    private var baseDir : Paths.HomebrewDir
+    
+    init() {
+        baseDir = Shell.fileExists("\(HomebrewDir.opt.rawValue)/bin/brew") ? .opt : .usr
+    }
+    
+    // - MARK: Binaries
+    
+    public static var valet: String {
+        return "/Users/\(whoami)/.composer/vendor/bin/valet"
+    }
+    
+    public static var brew: String {
+        return "\(binPath)/brew"
+    }
+    
+    public static var php: String {
+        return "\(binPath)/php"
+    }
+    
+    public static var phpConfig: String {
+        return "\(binPath)/php-config"
+    }
+    
+    // - MARK: Paths
+    
+    public static var whoami: String {
+        return String(Shell.pipe("whoami").split(separator: "\n")[0])
+    }
+    
+    public static var binPath: String {
+        return "\(shared.baseDir.rawValue)/bin"
+    }
+    
+    public static var optPath: String {
+        return "\(shared.baseDir.rawValue)/opt"
+    }
+    
+    public static var etcPath: String {
+        return "\(shared.baseDir.rawValue)/etc"
+    }
+    
+    // MARK: - Enum
+    
+    public enum HomebrewDir: String {
+        case opt = "/opt/homebrew"
+        case usr = "/usr/local"
+    }
+    
+}

phpmon-common/Core/Shell.swift

@@ -0,0 +1,179 @@
+//
+//  Shell.swift
+//  PHP Monitor
+//
+//  Copyright © 2021 Nico Verbruggen. All rights reserved.
+//
+
+import Cocoa
+
+public class Shell {
+    
+    // MARK: - Invoke static functions
+    
+    public static func run(
+        _ command: String,
+        requiresPath: Bool = false
+    ) {
+        Shell.user.run(command, requiresPath: requiresPath)
+    }
+    
+    public static func pipe(
+        _ command: String,
+        requiresPath: Bool = false
+    ) -> String {
+        return Shell.user.pipe(command, requiresPath: requiresPath)
+    }
+    
+    // MARK: - Singleton
+    
+    /**
+     We now require macOS 11, so no need to detect which terminal to use.
+     */
+    public var shell: String = "/bin/sh"
+    
+    /**
+     Singleton to access a user shell (with --login)
+     */
+    public static let user = Shell()
+    
+    /**
+     Runs a shell command without using the output.
+     Uses the default shell.
+     
+     - Parameter command: The command to run
+     - Parameter requiresPath: By default, the PATH is not resolved but some binaries might require this
+     */
+    private func run(
+        _ command: String,
+        requiresPath: Bool = false
+    ) {
+        // Equivalent of piping to /dev/null; don't do anything with the string
+        _ = Shell.pipe(command, requiresPath: requiresPath)
+    }
+    
+    /**
+     Runs a shell command and returns the output.
+     
+     - Parameter command: The command to run
+     - Parameter requiresPath: By default, the PATH is not resolved but some binaries might require this
+     */
+    private func pipe(
+        _ command: String,
+        requiresPath: Bool = false
+    ) -> String {
+        let shellOutput = self.executeSynchronously(command, requiresPath: requiresPath)
+        let hasError = (
+            shellOutput.standardOutput == ""
+            && shellOutput.errorOutput.lengthOfBytes(using: .utf8) > 0
+        )
+        return !hasError ? shellOutput.standardOutput : shellOutput.errorOutput
+    }
+    
+    /**
+     Runs the command and returns a `ShellOutput` object, which contains info about the process.
+     
+     - Parameter command: The command to run
+     - Parameter requiresPath: By default, the PATH is not resolved but some binaries might require this
+     - Parameter waitUntilExit: Waits for the command to complete before returning the `ShellOutput`
+     */
+    public func executeSynchronously(
+        _ command: String,
+        requiresPath: Bool = false
+    ) -> Shell.Output {
+        
+        let outputPipe = Pipe()
+        let errorPipe = Pipe()
+        
+        let task = self.createTask(for: command, requiresPath: requiresPath)
+        task.standardOutput = outputPipe
+        task.standardError = errorPipe
+        task.launch()
+        task.waitUntilExit()
+    
+        return Shell.Output(
+            standardOutput: String(
+                data: outputPipe.fileHandleForReading.readDataToEndOfFile(),
+                encoding: .utf8
+            )!,
+            errorOutput: String(
+                data: errorPipe.fileHandleForReading.readDataToEndOfFile(),
+                encoding: .utf8
+            )!,
+            task: task
+        )
+    }
+    
+    /**
+     Checks if a file exists at the provided path.
+     Uses `/bin/echo` instead of the `builtin` (which does not support `-n`).
+     */
+    public static func fileExists(_ path: String) -> Bool {
+        return Shell.pipe("if [ -f \(path) ]; then /bin/echo -n \"0\"; fi") == "0"
+    }
+    
+    /**
+     Creates a new process with the correct PATH and shell.
+     */
+    public func createTask(for command: String, requiresPath: Bool) -> Process {
+        let tailoredCommand = requiresPath
+        ? "export PATH=\(Paths.binPath):$PATH && \(command)"
+        : command
+        
+        let task = Process()
+        task.launchPath = self.shell
+        task.arguments = ["--login", "-c", tailoredCommand]
+        
+        return task
+    }
+    
+    public static func captureOutput(
+        _ task: Process,
+        didReceiveStdOutData: @escaping (String) -> Void,
+        didReceiveStdErrData: @escaping (String) -> Void
+    ) {
+        let outputPipe = Pipe()
+        let errorPipe = Pipe()
+        
+        task.standardOutput = outputPipe
+        task.standardError = errorPipe
+        
+        [(outputPipe, didReceiveStdOutData), (errorPipe, didReceiveStdErrData)].forEach {
+            (pipe: Pipe, callback: @escaping (String) -> Void) in
+            pipe.fileHandleForReading.waitForDataInBackgroundAndNotify()
+            NotificationCenter.default.addObserver(
+                forName: NSNotification.Name.NSFileHandleDataAvailable,
+                object: pipe.fileHandleForReading,
+                queue: nil
+            ) { notification in
+                if let outputString = String(data: pipe.fileHandleForReading.availableData, encoding: String.Encoding.utf8) {
+                    callback(outputString)
+                }
+                pipe.fileHandleForReading.waitForDataInBackgroundAndNotify()
+            }
+        }
+    }
+    
+    public static func haltCapturingOutput(_ task: Process) {
+        if let pipe = task.standardOutput as? Pipe {
+            NotificationCenter.default.removeObserver(pipe.fileHandleForReading)
+        }
+        if let pipe = task.standardError as? Pipe {
+            NotificationCenter.default.removeObserver(pipe.fileHandleForReading)
+        }
+    }
+    
+    public class Output {
+        public let standardOutput: String
+        public let errorOutput: String
+        public let task: Process
+        
+        init(standardOutput: String,
+             errorOutput: String,
+             task: Process) {
+            self.standardOutput = standardOutput
+            self.errorOutput = errorOutput
+            self.task = task
+        }
+    }
+}