swift 编写第一个CLI程序

import PackageDescription

let package = Package(
    name: "Counter",
    dependencies: [
        // Dependencies declare other packages that this package depends on.
        // .package(url: /* package url */, from: "1.0.0"),
        .package(url: "https://github.com/apple/swift-argument-parser.git", from: "1.0.0")
    ],
    targets: [
        // Targets are the basic building blocks of a package. A target can define a module or a test suite.
        // Targets can depend on other targets in this package, and on products in packages this package depends on.
        .executableTarget(
            name: "Counter",
            dependencies: [.product(name: "ArgumentParser", package: "swift-argument-parser")]),
    ]
)

// main.swift
let counter = Counter()

do {
   try counter.run()
} catch {
    print("An error occurred")
}

// Counter.swift
import Foundation

public struct Counter {
    private var arguments: [String]
    
    init(arguments: [String] = CommandLine.arguments) {
        self.arguments = arguments
    }
    
    public func run() throws {
        print("test")
    }
}

// 1 @Argument
@Argument var inputFile: String
@Argument var outputFile: String
// 这种情况对应到命令行我们就需要 Counter test1.txt test2.txt ，以属性的顺序给定参数。并且不需要指定

// 2. @Option
@Option var inputFile: String
@Option var outputFile: String
// 这种情况对应到命令行我们就需要 Counter --input-file test1.txt --output-file test2.txt ，当然顺序可以随意，只要指定即可。当然我们也可以@Option(name: help:)等初始化方法指定提示语、简写等等

// 2. @Flag
@Option var inputFile: String
@Option var outputFile: String
@Flag var verbose: Bool = false
// 这种情况对应到命令行我们就需要 Counter --verbose --input-file test1.txt --output-file test2.txt。

import ArgumentParser
import Foundation

@main
struct Counter: ParsableCommand {
    @Option(name: [.short, .customLong("input")], help: "A file to read")
    var inputFile: String
    
    @Option(name: [.short, .customLong("output")], help: "A file to save word counts to")
    var outputFile:String
    
    
    @Flag(name: .shortAndLong, help: "Print status updates while counting") var verbose: Bool = false
    
    mutating func run() throws {
        if verbose {
            print("""
                Counting words in '\(inputFile)' \
                and write result into '\(outputFile)'
                """)
        }
        
        guard let input = try? String(contentsOfFile: inputFile) else {
            throw RuntimeError("Can't read \(inputFile) contents")
        }
        
        let words = input.components(separatedBy: .whitespacesAndNewlines)
            .map { word in
                word.trimmingCharacters(in: CharacterSet.alphanumerics.inverted).lowercased()
            }
            .compactMap { word in
                word.isEmpty ? nil : word
            }
        
        let counts = Dictionary(grouping: words, by: { $0 })
            .mapValues { $0.count }
            .sorted(by: { $0.value > $1.value })
        
        if verbose {
            print("found \(counts.count) words")
        }
        
        let output: String = counts.map { word, count in
            "\(word): \(count)"
        }.joined(separator: "\n")
        
        guard let _ = try? output.write(toFile: outputFile, atomically: true, encoding: .utf8) else {
            throw RuntimeError("Can't write to \(outputFile)")
        }
    }
}

struct RuntimeError: Error, CustomStringConvertible {
    var description: String
    
    init(_ description: String) {
        self.description = description
    }
    
}