Removed getSwiftPMDefaultTemplate

- Fixed some typos
- add-template is now more robust when determining if we have a path or web url
- rough implementation of update-template

Author: Miguel Perez

Sources/Commands/SwiftPackageTool.swift

@@ -77,6 +77,7 @@ extension SwiftPackageTool {
             if let index = subCommands.firstIndex(where: { $0 == Init.self }) {
                 subCommands.insert(Create.self, at: index + 1)
                 subCommands.insert(AddTemplate.self, at: index + 2)
+                subCommands.insert(UpdateTemplate.self, at: index + 3)
             }
         }
 
@@ -223,7 +224,7 @@ extension SwiftPackageTool {
 
         func run(_ swiftTool: SwiftTool) throws {
             guard let cwd = localFileSystem.currentWorkingDirectory else {
-                throw InternalError("Could not find the current working directroy.")
+                throw InternalError("Could not find the current working directory.")
             }
 
             guard let configPath = try swiftTool.getConfigPath() else {
@@ -267,7 +268,7 @@ extension SwiftPackageTool {
 
         func run(_ swiftTool: SwiftTool) throws {
             guard let cwd = localFileSystem.currentWorkingDirectory else {
-                throw InternalError("Could not find the current working directroy.")
+                throw InternalError("Could not find the current working directory.")
             }
 
             guard let configPath = try swiftTool.getConfigPath() else {
@@ -315,15 +316,17 @@ extension SwiftPackageTool {
                 throw InternalError("Could not get the current working directory")
             }
 
-            if localFileSystem.exists(AbsolutePath(url)) {
-                let currentTemplateLocation = AbsolutePath(url)
-                let templateDirectory = configPath.appending(components: "templates", "new-package", url)
-                
-                guard localFileSystem.exists(currentTemplateLocation) && localFileSystem.isDirectory(currentTemplateLocation) else {
-                    throw InternalError("Template folder \(url) could not be found in: \(cwd)")
+            if let path = try? AbsolutePath(validating: url) {
+                if localFileSystem.exists(path) {
+                    let currentTemplateLocation = path
+                    let templateDirectory = configPath.appending(components: "templates", "new-package", url)
+                    
+                    guard localFileSystem.exists(currentTemplateLocation) && localFileSystem.isDirectory(currentTemplateLocation) else {
+                        throw InternalError("Template folder \(url) could not be found in: \(cwd)")
+                    }
+                    
+                    try localFileSystem.copy(from: currentTemplateLocation, to: templateDirectory)
                 }
-                
-                try localFileSystem.copy(from: currentTemplateLocation, to: templateDirectory)
             } else {
                 let templatePath: AbsolutePath
                 let provider = GitRepositoryProvider()
@@ -341,6 +344,32 @@ extension SwiftPackageTool {
         }
     }
 
+    struct UpdateTemplate: SwiftCommand {
+        static let configuration = CommandConfiguration(
+            abstract: "Update template from remote")
+        
+        @OptionGroup(_hiddenFromHelp: true)
+        var swiftOptions: SwiftToolOptions
+        
+        @Argument(help: "Template to update")
+        var templateName: String
+        
+        func run(_ swiftTool: SwiftTool) throws {
+            guard let configPath = try swiftTool.getConfigPath() else {
+                throw InternalError("Could not find config path")
+            }
+            
+            guard localFileSystem.exists(configPath.appending(components: "templates", "new-package", templateName)) else {
+                throw InternalError("Could not find \(templateName)")
+            }
+            
+            let provider = GitRepositoryProvider()
+            let templatePath = configPath.appending(components: "templates", "new-package", templateName)
+            
+            try provider.pull(repository: RepositorySpecifier(url: templatePath.pathString), to: templatePath)
+        }
+    }
+    
     struct Format: SwiftCommand {
         static let configuration = CommandConfiguration(
             commandName: "_format")

Sources/SourceControl/GitRepository.swift

@@ -107,6 +107,10 @@ public struct GitRepositoryProvider: RepositoryProvider {
         try self.fetch(repository: repository, to: path, mirror: true)
     }
 
+    public func pull(repository: RepositorySpecifier, to path: AbsolutePath) throws {
+        try self.callGit("pull", "-C", path.pathString, repository: repository)
+    }
+    
     public func isValidDirectory(_ directory: String) -> Bool {
         // Provides better feedback when mistakingly using url: for a dependency that
         // is a local package. Still allows for using url with a local package that has

Sources/Workspace/InitPackage.swift

@@ -148,7 +148,11 @@ public final class InitPackage {
                                  name: packageName)
             }
         } else {
-            let packageTemplate = getSwiftPMDefaultTemplate(packageType: packageType)
+            let packageTemplate = PackageTemplate(sourcesDirectory: RelativePath("./Sources"),
+                                                  testsDirectory: nil,
+                                                  createSubDirectoryForModule: false,
+                                                  packageType: packageType)
+           
             try writePackageStructure(template: packageTemplate)
         }
     }
@@ -161,26 +165,6 @@ public final class InitPackage {
 
         try writePackageStructure(template: template)
     }
-    
-    private func getSwiftPMDefaultTemplate(packageType: InitPackage.PackageType,
-                                           sources: RelativePath = .init("./Sources"),
-                                           tests: RelativePath? = nil,
-                                           createSubDirectoryForModule: Bool = false) -> InitPackage.PackageTemplate {
-        // Even if we are making a "classic" package that doesn't use a template we should till use templates
-        // for consistency within the codebase
-        switch InitPackage.createPackageMode {
-        case .new:
-            return InitPackage.PackageTemplate(sourcesDirectory: sources,
-                                               testsDirectory: tests,
-                                               createSubDirectoryForModule: createSubDirectoryForModule,
-                                               packageType: packageType)
-        case .legacy:
-            return InitPackage.PackageTemplate(sourcesDirectory: RelativePath("./Sources"),
-                                               testsDirectory: RelativePath("./Tests"),
-                                               createSubDirectoryForModule: true,
-                                               packageType: packageType)
-        }
-    }
 
     private func copyTemplate(fileSystem: FileSystem, sourcePath: AbsolutePath, destinationPath: AbsolutePath, name: String) throws {
         // Recursively copy the template package