Rename

Author: ShotaKashihara

Sources/AtCoderLibrary/Command/New.swift

@@ -27,15 +27,15 @@ public struct New: ParsableCommand {
         FileManager.default.changeCurrentDirectoryPath(contestName)
 
         let alphabets = problems.map(\.context.alphabet).map(Character.init)
-        try PackageSwift(contestName: contestName, alphabets: alphabets).write()
-        try Readme(contest: contest, problems: problems).write()
+        try PackageSwift(contestName: contestName, alphabets: alphabets).codeGenerate()
+        try Readme(contest: contest, problems: problems).codeGenerate()
         try problems.forEach {
-            try Source(problem: $0).write()
+            try Source(problem: $0).codeGenerate()
         }
         try problems.forEach {
-            try Test(problem: $0).write()
+            try Test(problem: $0).codeGenerate()
         }
-        try TestLibrary().write()
+        try TestLibrary().codeGenerate()
 
         if open {
             SwiftShell.run("cd", contestName)

Sources/AtCoderLibrary/Command/New/CodeTemplate.swift

@@ -0,0 +1,21 @@
+import Foundation
+
+protocol CodeTemplate {
+    var fileName: String { get }
+    var directory: String? { get }
+    var source: String { get }
+}
+
+extension CodeTemplate {
+    func codeGenerate() throws {
+        if let directory = directory {
+            try FileManager.default.createDirectory(atPath: directory, withIntermediateDirectories: true)
+        }
+        let filePath = "\(directory ?? ".")/\(fileName)"
+        guard !FileManager.default.fileExists(atPath: filePath) else {
+            print("Skip file creation because the file exists.", "path: ", filePath)
+            return
+        }
+        try source.write(toFile: filePath, atomically: true, encoding: .utf8)
+    }
+}

Sources/AtCoderLibrary/Command/New/Templates/PackageSwift.swift

@@ -0,0 +1,28 @@
+struct PackageSwift: CodeTemplate {
+    let contestName: String
+    let alphabets: [Character]
+    let fileName = "Package.swift"
+    let directory: String? = nil
+    var source: String {
+        """
+        // swift-tools-version:5.3
+        import PackageDescription
+
+        let package = Package(
+            name: "\(contestName.uppercased())",
+            dependencies: [],
+            targets: [
+        \(alphabets.sorted()
+                    .map {
+        """
+                .target(name: "\($0)"),
+                .testTarget(name: "\($0)Tests", dependencies: ["\($0)", "TestLibrary"]),
+        """
+                    }
+                    .joined(separator: "\n"))
+                .target(name: "TestLibrary", path: "Tests/TestLibrary"),
+            ]
+        )
+        """
+    }
+}

Sources/AtCoderLibrary/Command/New/Templates/Readme.swift

@@ -0,0 +1,21 @@
+struct Readme: CodeTemplate {
+    let contest: Contest
+    let problems: [Problem]
+    let fileName = "README.md"
+    let directory: String? = nil
+    var source: String {
+        let problems = self.problems.sorted(by: {
+            $0.context.alphabet < $1.context.alphabet
+        })
+        return """
+        # [\(contest.name)](\(contest.url))
+
+        問題名 | 実行時間制限 | メモリ制限
+        :-- | --: | --:
+        \(problems.map { problem in """
+        [\(problem.context.alphabet) \(problem.name)](\(problem.url)) | \(Double(problem.timeLimit)/1000) sec | \(problem.memoryLimit) MB
+        """}.joined(separator: "\n"))
+
+        """
+    }
+}

Sources/AtCoderLibrary/Command/New/Templates/Source.swift

@@ -0,0 +1,14 @@
+struct Source: CodeTemplate {
+    let problem: Problem
+    let fileName = "main.swift"
+    var directory: String? { "Sources/\(problem.context.alphabet)" }
+    var source: String {
+        """
+        // \(problem.context.alphabet) - \(problem.name)
+        // \(problem.url)
+        // 実行制限時間: \(Double(problem.timeLimit)/1000) sec
+        import Foundation
+
+        """
+    }
+}

Sources/AtCoderLibrary/Command/New/Templates/Test.swift

@@ -0,0 +1,43 @@
+struct Test: CodeTemplate {
+    let problem: Problem
+    var className: String {
+        if Int(problem.context.alphabet) != nil {
+            // [!] Class name can not start with a number.
+            return "_\(problem.context.alphabet)Tests"
+        }
+        return "\(problem.context.alphabet)Tests"
+    }
+    var fileName: String { "\(problem.context.alphabet)Tests.swift" }
+    var directory: String? { "Tests/\(problem.context.alphabet)Tests" }
+    var source: String {
+        """
+        import XCTest
+        import TestLibrary
+
+        let cases: [TestCase] = [
+        \(problem.tests.map(Self.testCase).joined(separator: "\n"))
+        ]
+
+        final class \(className): XCTestCase, TimeLimit {
+            let timeLimit: TimeInterval = \(Double(problem.timeLimit)/1000)
+
+            func testExample() throws {
+                try cases.forEach(solve)
+            }
+        }
+        """
+    }
+
+    private static func testCase(_ test: Problem.Test) -> String {
+        let inputs = test.input.split(separator: "\n")
+        let outputs = test.output.split(separator: "\n")
+        return """
+            (#filePath, #line,
+            \"""
+            \(inputs.map { "\($0)" }.joined(separator: "\n"))
+            \""", \"""
+            \(outputs.map { "\($0)" }.joined(separator: "\n"))
+            \"""),
+            """
+    }
+}

Sources/AtCoderLibrary/Command/New/Templates/TestLibrary.swift

@@ -0,0 +1,82 @@
+struct TestLibrary: CodeTemplate {
+    let directory: String? = "Tests/TestLibrary"
+    let fileName = "TestLibrary.swift"
+    var source: String {
+        """
+        import XCTest
+        import class Foundation.Bundle
+
+        public protocol TimeLimit {
+            var timeLimit: TimeInterval { get }
+        }
+
+        public typealias TestCase = (file: StaticString, line: UInt, input: String, expected: String)
+
+        public extension TimeLimit where Self: XCTestCase {
+            func solve(file: StaticString, line: UInt, input: String, expected: String) throws {
+                // Some of the APIs that we use below are available in macOS 10.13 and above.
+                guard #available(macOS 10.13, *) else {
+                    return
+                }
+                let expected = expected.last == "\\n" ? expected : expected + "\\n"
+                var error = ""
+                let exp = expectation(description: "")
+                let testTarget = String(describing: type(of: self))
+                    .replacingOccurrences(of: "Tests", with: "")
+                    .replacingOccurrences(of: "_", with: "")
+                let binary = productsDirectory.appendingPathComponent(testTarget)
+                let process = Process()
+                
+                addTeardownBlock {
+                    if process.isRunning {
+                        process.terminate()
+                    }
+                }
+                
+                process.executableURL = binary
+                let pipeInput = Pipe()
+                process.standardInput = pipeInput
+                let pipeOutput = Pipe()
+                process.standardOutput = pipeOutput
+                let pipeError = Pipe()
+                process.standardError = pipeError
+                
+                DispatchQueue.global().async {
+                    do {
+                        try process.run()
+                        pipeInput.fileHandleForWriting.write(input.data(using: .utf8)!)
+                        pipeInput.fileHandleForWriting.closeFile()
+                        process.waitUntilExit()
+                        exp.fulfill()
+                        error = String(data: pipeError.fileHandleForReading.readDataToEndOfFile(), encoding: .utf8)!
+                    } catch (let e) {
+                        error = e.localizedDescription
+                    }
+                }
+                let result = XCTWaiter.wait(for: [exp], timeout: timeLimit)
+                switch result {
+                case .completed:
+                    if error.isEmpty {
+                        let data = pipeOutput.fileHandleForReading.readDataToEndOfFile()
+                        let output = String(data: data, encoding: .utf8)!
+                        XCTAssertEqual(output, expected, file: file, line: line)
+                    } else {
+                        XCTFail("RE: \\(error)", file: file, line: line)
+                    }
+                case .timedOut:
+                    XCTFail("TLE: Exceeded timeout of \\(timeLimit) seconds", file: file, line: line)
+                default:
+                    XCTFail("Unrecognized error.", file: file, line: line)
+                }
+            }
+
+            private var productsDirectory: URL {
+                for bundle in Bundle.allBundles where bundle.bundlePath.hasSuffix(".xctest") {
+                    return bundle.bundleURL.deletingLastPathComponent()
+                }
+                fatalError("couldn't find the products directory")
+            }
+        }
+        """
+    }
+}