From f795575c3b124162c2b90cd265fae4b8d1f4b77a Mon Sep 17 00:00:00 2001 From: Michael Newton Date: Thu, 4 Jul 2013 09:56:33 +0100 Subject: [PATCH] Clean up with Fantomas --- NuGetPlus.Console/Program.fs | 80 ++-- NuGetPlus.Core/ProjectManagement.fs | 424 +++++++++++------- NuGetPlus.Core/ProjectSystem.fs | 122 +++-- NuGetPlus.Core/XmlTransformer.fs | 32 +- NuGetPlus.TickSpec.Tests/Fixtures.fs | 28 +- .../ProjectStepDefinitions.fs | 192 ++++---- .../SolutionStepDefinitions.fs | 20 +- NuGetPlus.TickSpec.Tests/TestUtilities.fs | 28 +- 8 files changed, 552 insertions(+), 374 deletions(-) diff --git a/NuGetPlus.Console/Program.fs b/NuGetPlus.Console/Program.fs index b08fefc..c124c33 100644 --- a/NuGetPlus.Console/Program.fs +++ b/NuGetPlus.Console/Program.fs @@ -1,90 +1,92 @@ module NuGetPlay.Main + open System open NuGet open NuGetPlus.ProjectManagement open UnionArgParser -type Argument = - | [] Action of string - | [] ProjectFile of string +type Argument = + | Action of string + | ProjectFile of string | PackageId of string | Version of string - with - interface IArgParserTemplate with - member s.Usage = - match s with - | Action _ -> "Specify an action: Install, Remove, Restore or Update" - | ProjectFile _ -> "Path to project file to update." - | PackageId _ -> "NuGet package id for action." - | Version _ -> "Optional specific version of package." + interface IArgParserTemplate with + member s.Usage = + match s with + | Action _ -> + "Specify an action: Install, Remove, Restore or Update" + | ProjectFile _ -> "Path to project file to update." + | PackageId _ -> "NuGet package id for action." + | Version _ -> "Optional specific version of package." -type ActionType = +type ActionType = | Install | Remove | Restore | Update -let processAction (a : string) = +let processAction(a : string) = match a.ToLower() with | "install" -> Install | "remove" -> Remove | "restore" -> Restore | "update" -> Update - | _ -> failwith "Invalid Action; please use install, remove, restore or update." + | _ -> + failwith + "Invalid Action; please use install, remove, restore or update." -let processProjectFile (f : string) = +let processProjectFile(f : string) = match IO.File.Exists(f) with | true -> f | false -> failwith "ProjectFile does not exist." -let processVersion (v : string) = - SemanticVersion(v) +let processVersion(v : string) = SemanticVersion(v) [] let main argv = - try + try let parser = UnionArgParser() let results = parser.Parse() let action = results.PostProcessResult <@ Action @> processAction - let proj = results.PostProcessResult <@ ProjectFile @> processProjectFile + let proj = + results.PostProcessResult <@ ProjectFile @> processProjectFile let maybePackage = results.TryGetResult <@ PackageId @> let version = results.TryPostProcessResult <@ Version @> processVersion - printfn "Action type: %A" action printfn "Project file: %s" proj match maybePackage with - | Some package -> - printfn "Package ID: %s" package + | Some package -> printfn "Package ID: %s" package | None -> () - match version with | None -> () | Some v -> printfn "Version: %A" v - - let checkPackage mp = + let checkPackage mp = match mp with - | None -> - failwith "A package is required for this action" + | None -> failwith "A package is required for this action" | Some p -> p - match action with - | Install -> + | Install -> match version with | None -> InstallReference proj (checkPackage maybePackage) - | Some v -> InstallReferenceOfSpecificVersion proj (checkPackage maybePackage) v - | Update -> + | Some v -> + InstallReferenceOfSpecificVersion proj + (checkPackage maybePackage) v + | Update -> match version with | None -> UpdateReference proj (checkPackage maybePackage) - | Some v -> UpdateReferenceToSpecificVersion proj (checkPackage maybePackage) v - | Remove -> - RemoveReference proj (checkPackage maybePackage) - | Restore -> + | Some v -> + UpdateReferenceToSpecificVersion proj + (checkPackage maybePackage) v + | Remove -> RemoveReference proj (checkPackage maybePackage) + | Restore -> match maybePackage with - | Some package -> failwith "PackageId provided for restore action - restore will always restore the whole packages.config" + | Some package -> + failwith + "PackageId provided for restore action - restore will always restore the whole packages.config" | None -> () RestoreReferences proj 0 - with - | ex -> + with + | ex -> printfn "%A" ex - 1 + 1 \ No newline at end of file diff --git a/NuGetPlus.Core/ProjectManagement.fs b/NuGetPlus.Core/ProjectManagement.fs index 473fb6d..6cf3cc6 100644 --- a/NuGetPlus.Core/ProjectManagement.fs +++ b/NuGetPlus.Core/ProjectManagement.fs @@ -1,4 +1,5 @@ module NuGetPlus.ProjectManagement + open System open System.Collections.Generic open System.IO @@ -8,269 +9,354 @@ open System.Xml.Linq open NuGet open Microsoft.Build.Evaluation -let inline private grabCompatible (project : IProjectSystem) f name = - match project.TryGetCompatibleItems(f ()) with +let inline private grabCompatible (project : IProjectSystem) f name = + match project.TryGetCompatibleItems(f()) with | (true, result) -> result | (false, _) -> Seq.empty -let private getFilteredAssemblies (package : IPackage) (project : IProjectSystem) assemblyReferences = +let private getFilteredAssemblies (package : IPackage) + (project : IProjectSystem) assemblyReferences = match package.PackageAssemblyReferences with | null -> assemblyReferences - | par -> + | par -> match project.TryGetCompatibleItems(par) with - | (true, items) -> - Seq.filter (fun (assembly : IPackageAssemblyReference) -> not <| Seq.exists (fun (pr : PackageReferenceSet) -> pr.References.Contains(assembly.Name, StringComparer.OrdinalIgnoreCase)) items) assemblyReferences - | (false, _) -> - assemblyReferences + | (true, items) -> + Seq.filter + (fun (assembly : IPackageAssemblyReference) -> + not + <| Seq.exists + (fun (pr : PackageReferenceSet) -> + pr.References.Contains + (assembly.Name, + StringComparer.OrdinalIgnoreCase)) items) + assemblyReferences + | (false, _) -> assemblyReferences -let private fileTransformers : IDictionary = - dict [(".transform", XmlTransformer() :> IPackageFileTransformer);(".pp", Preprocessor() :> IPackageFileTransformer)] +let private fileTransformers : IDictionary = + dict [(".transform", XmlTransformer() :> IPackageFileTransformer); + (".pp", Preprocessor() :> IPackageFileTransformer)] -let private getFiles project (package : IPackage) = - let assemblyReferences = - grabCompatible project (fun () -> package.AssemblyReferences) "assembly references" - let frameworkReferences = - grabCompatible project (fun () -> package.FrameworkAssemblies) "framework assemblies" - let contentFiles = +let private getFiles project (package : IPackage) = + let assemblyReferences = + grabCompatible project (fun () -> package.AssemblyReferences) + "assembly references" + let frameworkReferences = + grabCompatible project (fun () -> package.FrameworkAssemblies) + "framework assemblies" + let contentFiles = grabCompatible project (package.GetContentFiles) "content files" - let buildFiles = + let buildFiles = grabCompatible project (package.GetBuildFiles) "build files" assemblyReferences, frameworkReferences, contentFiles, buildFiles -let private RemoveFilesFromProj packageInstallPath (package : IPackage) (project : IProjectSystem) (localRepo : IPackageRepository) = +let private RemoveFilesFromProj packageInstallPath (package : IPackage) + (project : IProjectSystem) (localRepo : IPackageRepository) = let packagesConfig = "packages.config" - let otherPackages = + let otherPackages = (XDocument.Parse <| project.OpenFile(packagesConfig).ReadToEnd()) .Descendants(XName.Get "package") - |> Seq.filter (fun p -> p.Attribute(XName.Get "id").Value <> package.Id) - |> Seq.map (fun p -> localRepo.FindPackage(p.Attribute(XName.Get "id").Value, new SemanticVersion(p.Attribute(XName.Get "version").Value), true, true)) - |> Seq.filter (fun p -> p <> null) + |> Seq.filter(fun p -> p.Attribute(XName.Get "id").Value <> package.Id) + |> Seq.map + (fun p -> + localRepo.FindPackage + (p.Attribute(XName.Get "id").Value, + + new SemanticVersion(p.Attribute(XName.Get "version").Value), + true, true)) + |> Seq.filter(fun p -> p <> null) |> Seq.toList - let inUseByOtherPackages = - if List.length otherPackages > 0 then + let inUseByOtherPackages = + if List.length otherPackages > 0 then otherPackages - |> Seq.map (fun p -> getFiles project p) + |> Seq.map(fun p -> getFiles project p) |> Seq.reduce - (fun acc next -> - let a, f, c, b = acc - let a', f', c', b' = next - (Seq.append a a', Seq.append f f', Seq.append c c', Seq.append b b')) - |> fun (a, f, c, b) -> - Seq.distinctBy (fun (assembly : IPackageAssemblyReference) -> assembly.Name) a, - Seq.distinctBy (fun (frameworkRef : FrameworkAssemblyReference) -> frameworkRef.AssemblyName) f, - c - |> Seq.filter (fun (contentFile : IPackageFile) -> - not <| fileTransformers.ContainsKey(Path.GetExtension contentFile.EffectivePath)) - |> Seq.distinctBy (fun contentFile -> contentFile.EffectivePath, contentFile.TargetFramework.Version), - Seq.distinctBy (fun (buildFile : IPackageFile) -> buildFile.EffectivePath, buildFile.TargetFramework.Version) b - else - (Seq.empty, Seq.empty, Seq.empty, Seq.empty) - let assemblyReferencesToDelete, frameworkReferencesToDelete, contentFilesToDelete, buildFilesToDelete = + (fun acc next -> + let a, f, c, b = acc + let a', f', c', b' = next + (Seq.append a a', Seq.append f f', Seq.append c c', + Seq.append b b')) + |> fun (a, f, c, b) -> + + Seq.distinctBy + (fun (assembly : IPackageAssemblyReference) -> assembly.Name) + a, + + Seq.distinctBy + (fun (frameworkRef : FrameworkAssemblyReference) -> + frameworkRef.AssemblyName) f, + + c + |> Seq.filter + (fun (contentFile : IPackageFile) -> + not + <| fileTransformers.ContainsKey + (Path.GetExtension contentFile.EffectivePath)) + |> Seq.distinctBy + (fun contentFile -> + contentFile.EffectivePath, + contentFile.TargetFramework.Version), + + Seq.distinctBy + (fun (buildFile : IPackageFile) -> + buildFile.EffectivePath, + buildFile.TargetFramework.Version) b + else (Seq.empty, Seq.empty, Seq.empty, Seq.empty) + let (assemblyReferencesToDelete, frameworkReferencesToDelete, + contentFilesToDelete, buildFilesToDelete) = let a, f, c, b = getFiles project package let a', f', c', b' = inUseByOtherPackages - Seq.filter (fun (assembly : IPackageAssemblyReference) -> Seq.exists (fun (assembly' : IPackageAssemblyReference) -> assembly.Name = assembly'.Name) a' |> not) a, - Seq.filter (fun (assembly : FrameworkAssemblyReference) -> Seq.exists (fun (assembly' : FrameworkAssemblyReference) -> assembly.AssemblyName = assembly'.AssemblyName) f' |> not) f, - Seq.filter ( - fun (contentFile : IPackageFile) -> - Seq.exists ( - fun (contentFile' : IPackageFile) -> - (contentFile.EffectivePath, contentFile.TargetFramework.Version) = (contentFile'.EffectivePath, contentFile'.TargetFramework.Version)) c' |> not) c, - Seq.filter ( - fun (buildFile : IPackageFile) -> - Seq.exists ( - fun (buildFile' : IPackageFile) -> - (buildFile.EffectivePath, buildFile.TargetFramework.Version) = (buildFile'.EffectivePath, buildFile'.TargetFramework.Version)) b' |> not) b + + Seq.filter + (fun (assembly : IPackageAssemblyReference) -> + Seq.exists + (fun (assembly' : IPackageAssemblyReference) -> + assembly.Name = assembly'.Name) a' |> not) a, + + Seq.filter + (fun (assembly : FrameworkAssemblyReference) -> + Seq.exists + (fun (assembly' : FrameworkAssemblyReference) -> + assembly.AssemblyName = assembly'.AssemblyName) f' + |> not) f, + + Seq.filter + (fun (contentFile : IPackageFile) -> + Seq.exists + (fun (contentFile' : IPackageFile) -> + (contentFile.EffectivePath, + contentFile.TargetFramework.Version) = ( + contentFile'.EffectivePath, + + contentFile'.TargetFramework.Version)) + c' |> not) c, + + Seq.filter + (fun (buildFile : IPackageFile) -> + Seq.exists + (fun (buildFile' : IPackageFile) -> + (buildFile.EffectivePath, + buildFile.TargetFramework.Version) = ( + buildFile'.EffectivePath, + + buildFile'.TargetFramework.Version)) + b' |> not) b project.DeleteFiles(contentFilesToDelete, otherPackages, fileTransformers) - assemblyReferencesToDelete |> Seq.iter (fun a -> project.RemoveReference(a.Name)) + assemblyReferencesToDelete + |> Seq.iter(fun a -> project.RemoveReference(a.Name)) buildFilesToDelete - |> Seq.map (fun bf -> Path.Combine(packageInstallPath, bf.Path)) - |> Seq.iter (fun fullPath -> project.RemoveImport(fullPath)) + |> Seq.map(fun bf -> Path.Combine(packageInstallPath, bf.Path)) + |> Seq.iter(fun fullPath -> project.RemoveImport(fullPath)) -let private AddFilesToProj packageInstallPath package project = - let assemblyReferences, frameworkReferences, contentFiles, buildFiles = +let private AddFilesToProj packageInstallPath package project = + let assemblyReferences, frameworkReferences, contentFiles, buildFiles = getFiles project package - if - (Seq.isEmpty assemblyReferences - && Seq.isEmpty frameworkReferences - && Seq.isEmpty contentFiles - && Seq.isEmpty buildFiles) - && not (Seq.isEmpty package.AssemblyReferences && Seq.isEmpty package.FrameworkAssemblies && Seq.isEmpty (package.GetContentFiles()) && Seq.isEmpty (package.GetBuildFiles())) - then - failwith "Unable to find compatible items for framework %s in package %s." (project.TargetFramework.FullName) (package.GetFullName()) - let filteredAssemblyReferences = + if (Seq.isEmpty assemblyReferences && Seq.isEmpty frameworkReferences + && Seq.isEmpty contentFiles && Seq.isEmpty buildFiles) + && not + (Seq.isEmpty package.AssemblyReferences + && Seq.isEmpty package.FrameworkAssemblies + && Seq.isEmpty(package.GetContentFiles()) + && Seq.isEmpty(package.GetBuildFiles())) then + failwith + "Unable to find compatible items for framework %s in package %s." + (project.TargetFramework.FullName) (package.GetFullName()) + let filteredAssemblyReferences = getFilteredAssemblies package project assemblyReferences project.AddFiles(contentFiles, fileTransformers) frameworkReferences - |> Seq.filter (fun f -> not <| project.ReferenceExists(f.AssemblyName)) - |> Seq.iter (fun f -> project.AddFrameworkReference(f.AssemblyName)) - + |> Seq.filter(fun f -> not <| project.ReferenceExists(f.AssemblyName)) + |> Seq.iter(fun f -> project.AddFrameworkReference(f.AssemblyName)) filteredAssemblyReferences - |> Seq.filter (fun a -> not <| a.IsEmptyFolder()) - |> Seq.iter (fun a -> - let refPath = Path.Combine(packageInstallPath, a.Path) - if project.ReferenceExists(a.Name) then project.RemoveReference(a.Name) - project.AddReference(refPath, Stream.Null)) + |> Seq.filter(fun a -> not <| a.IsEmptyFolder()) + |> Seq.iter(fun a -> + let refPath = Path.Combine(packageInstallPath, a.Path) + if project.ReferenceExists(a.Name) then + project.RemoveReference(a.Name) + project.AddReference(refPath, Stream.Null)) -let private SortPackages (configDoc : XDocument) = +let private SortPackages(configDoc : XDocument) = configDoc.Element(XName.Get "packages").Elements(XName.Get "package") - |> Seq.sortBy (fun p -> (p.Attribute (XName.Get "id")).Value.ToLower()) - |> Seq.map (fun x -> x.Remove(); x) + |> Seq.sortBy(fun p -> (p.Attribute(XName.Get "id")).Value.ToLower()) + |> Seq.map(fun x -> + x.Remove() + x) |> Seq.toArray |> configDoc.Element(XName.Get "packages").Add -let private DeletePackageNode id (packagesNode : XElement) = +let private DeletePackageNode id (packagesNode : XElement) = packagesNode.Elements() - |> Seq.tryFind(fun e -> - e.Attribute (XName.Get "id") <> null && (e.Attribute (XName.Get "id")).Value = id) - |> function + |> Seq.tryFind + (fun e -> + e.Attribute(XName.Get "id") <> null + && (e.Attribute(XName.Get "id")).Value = id) + |> function | Some node -> node.Remove() | None -> () -let private UninstallFromPackagesConfigFile id (project : IProjectSystem) = +let private UninstallFromPackagesConfigFile id (project : IProjectSystem) = let fileName = "packages.config" - if project.FileExists(fileName) then + if project.FileExists(fileName) then project.OpenFile(fileName) - |> fun stream -> XDocument.Parse (stream.ReadToEnd()) + |> fun stream -> XDocument.Parse(stream.ReadToEnd()) |> Some - else - None - |> function - | None -> () - | Some configDoc -> - configDoc.Element(XName.Get "packages") - |> DeletePackageNode id - SortPackages configDoc - project.AddFile(fileName, fun (s : Stream) -> configDoc.Save(s)) + else None + |> function + | None -> () + | Some configDoc -> + configDoc.Element(XName.Get "packages") |> DeletePackageNode id + SortPackages configDoc + project.AddFile(fileName, fun (s : Stream) -> configDoc.Save(s)) -let private InstallToPackagesConfigFile (package : IPackage) (project : IProjectSystem) = +let private InstallToPackagesConfigFile (package : IPackage) + (project : IProjectSystem) = let fileName = "packages.config" - let configDoc = - use stream = - if not <| project.FileExists(fileName) then - using - (new IO.StreamWriter(project.CreateFile(fileName))) - (fun writer -> - writer.Write("")) + let configDoc = + use stream = + if not <| project.FileExists(fileName) then + using (new IO.StreamWriter(project.CreateFile(fileName))) + (fun writer -> writer.Write("")) project.OpenFile(fileName) - XDocument.Parse (stream.ReadToEnd()) - let packagesNode = - configDoc.Element(XName.Get "packages") + XDocument.Parse(stream.ReadToEnd()) + let packagesNode = configDoc.Element(XName.Get "packages") // Check if a version is already installed, and remove it... - DeletePackageNode package.Id packagesNode + DeletePackageNode package.Id packagesNode // Add the new version - let packageNode = - sprintf "" package.Id (package.Version.ToString()) (VersionUtility.GetShortFrameworkName project.TargetFramework) + let packageNode = + sprintf "" + package.Id (package.Version.ToString()) + (VersionUtility.GetShortFrameworkName project.TargetFramework) |> XElement.Parse packagesNode.Add packageNode SortPackages configDoc project.AddFile(fileName, fun (s : Stream) -> configDoc.Save(s)) -let private inferRepositoryDirectory projectDir = - let rec inner (currentDir : DirectoryInfo) = - if Array.length (currentDir.GetFiles("*.sln")) > 0 then - Some currentDir - else - if currentDir.Parent <> null then - inner currentDir.Parent - else - None +let private inferRepositoryDirectory projectDir = + let rec inner(currentDir : DirectoryInfo) = + if Array.length(currentDir.GetFiles("*.sln")) > 0 then Some currentDir + else if currentDir.Parent <> null then inner currentDir.Parent + else None let solutionDir = inner <| DirectoryInfo(projectDir) match solutionDir with - | Some dir -> - Path.Combine(dir.FullName, "packages") + | Some dir -> Path.Combine(dir.FullName, "packages") | None -> Path.Combine(projectDir, "packages") -let private GetRawManager (projectName : string) = - if String.IsNullOrWhiteSpace projectName then raise <| ArgumentException("projectName cannot be empty") +let private GetRawManager(projectName : string) = + if String.IsNullOrWhiteSpace projectName then + raise <| ArgumentException("projectName cannot be empty") let projectDir = Path.GetFullPath <| IO.Path.GetDirectoryName projectName let settings = Settings.LoadDefaultSettings(PhysicalFileSystem projectDir) let repositoryPath = match settings.GetRepositoryPath() with - | null -> - inferRepositoryDirectory projectDir + | null -> inferRepositoryDirectory projectDir | s -> s printfn "repo path: %s" repositoryPath let defaultPackageSource = PackageSource "https://nuget.org/api/v2/" - let packageSourceProvider = PackageSourceProvider (settings, [defaultPackageSource]) - let remoteRepository = packageSourceProvider.GetAggregate(PackageRepositoryFactory()) + let packageSourceProvider = + PackageSourceProvider(settings, [defaultPackageSource]) + let remoteRepository = + packageSourceProvider.GetAggregate(PackageRepositoryFactory()) let localRepository = SharedPackageRepository repositoryPath - let logger = { new ILogger - with - member x.Log(level, message, parameters) = Console.WriteLine("[{0}] {1}", level.ToString(), String.Format(message, parameters)) - member x.ResolveFileConflict(message) = FileConflictResolution() } - let packageManager = PackageManager( - remoteRepository, - DefaultPackagePathResolver(PhysicalFileSystem repositoryPath), - PhysicalFileSystem repositoryPath, - localRepository) + let logger = + { new ILogger with + member x.Log(level, message, parameters) = + Console.WriteLine + ("[{0}] {1}", level.ToString(), + String.Format(message, parameters)) + member x.ResolveFileConflict(message) = FileConflictResolution() } + let packageManager = + PackageManager + (remoteRepository, + DefaultPackagePathResolver(PhysicalFileSystem repositoryPath), + PhysicalFileSystem repositoryPath, localRepository) packageManager.Logger <- logger packageManager -let private GetManager projectName = +let private GetManager projectName = let packageManager = GetRawManager projectName let project = ProjectSystem(projectName) :> IProjectSystem - packageManager.PackageInstalling.Add(fun ev -> InstallToPackagesConfigFile ev.Package project) - packageManager.PackageInstalling.Add(fun ev -> AddFilesToProj ev.InstallPath ev.Package project) - packageManager.PackageUninstalling.Add(fun ev -> RemoveFilesFromProj ev.InstallPath ev.Package project packageManager.LocalRepository) - packageManager.PackageUninstalling.Add(fun ev -> UninstallFromPackagesConfigFile ev.Package.Id project) + packageManager.PackageInstalling.Add + (fun ev -> InstallToPackagesConfigFile ev.Package project) + packageManager.PackageInstalling.Add + (fun ev -> AddFilesToProj ev.InstallPath ev.Package project) + packageManager.PackageUninstalling.Add + (fun ev -> + RemoveFilesFromProj ev.InstallPath ev.Package project + packageManager.LocalRepository) + packageManager.PackageUninstalling.Add + (fun ev -> UninstallFromPackagesConfigFile ev.Package.Id project) packageManager -type private RestorePackage = { Id : string; Version : SemanticVersion } +type private RestorePackage = + { Id : string; + Version : SemanticVersion } -let private getRestorePackages projectName = - let packagesConfig = Path.Combine(Path.GetDirectoryName(projectName), "packages.config") - if File.Exists packagesConfig then +let private getRestorePackages projectName = + let packagesConfig = + Path.Combine(Path.GetDirectoryName(projectName), "packages.config") + if File.Exists packagesConfig then use stream = File.OpenRead(packagesConfig) - XDocument.Load(stream).Element(XName.Get "packages").Elements(XName.Get "package") - |> Seq.map (fun p -> { - Id = p.Attribute(XName.Get "id").Value - Version = SemanticVersion(p.Attribute(XName.Get "version").Value) - }) - else - Seq.empty + XDocument.Load(stream).Element(XName.Get "packages") + .Elements(XName.Get "package") + |> Seq.map + (fun p -> + { Id = p.Attribute(XName.Get "id").Value; + Version = + SemanticVersion(p.Attribute(XName.Get "version").Value) }) + else Seq.empty -let UpdateReferenceToSpecificVersion projectName packageId (version : SemanticVersion) = +let UpdateReferenceToSpecificVersion projectName packageId + (version : SemanticVersion) = let pm = GetManager projectName let existingPackage = pm.LocalRepository.FindPackage(packageId) pm.UninstallPackage(existingPackage, true, true) pm.InstallPackage(packageId, version, false, true) -let UpdateReference projectName (packageId : string) = +let UpdateReference projectName (packageId : string) = let pm = GetManager projectName let existingPackage = pm.LocalRepository.FindPackage(packageId) pm.UninstallPackage(existingPackage, true, true) pm.InstallPackage packageId -let InstallReferenceOfSpecificVersion projectName packageId (version : SemanticVersion) = +let InstallReferenceOfSpecificVersion projectName packageId + (version : SemanticVersion) = let manager = GetManager projectName let ok, package = manager.LocalRepository.TryFindPackage(packageId, version) - if ok then - manager.Logger.Log(MessageLevel.Info, "LocalRepository already contains package {0}, installing files.", packageId) + if ok then + manager.Logger.Log + (MessageLevel.Info, + "LocalRepository already contains package {0}, installing files.", + packageId) let project = ProjectSystem(projectName) :> IProjectSystem InstallToPackagesConfigFile package project - AddFilesToProj (manager.PathResolver.GetInstallPath package) package project - else - manager.InstallPackage(packageId, version, false, true) + AddFilesToProj (manager.PathResolver.GetInstallPath package) package + project + else manager.InstallPackage(packageId, version, false, true) -let InstallReference projectName packageId = +let InstallReference projectName packageId = let manager = GetManager projectName - let latest = manager.SourceRepository.FindPackage(packageId, VersionSpec(), false, false) - let ok, package = manager.LocalRepository.TryFindPackage(latest.Id, latest.Version) - if ok then - manager.Logger.Log(MessageLevel.Info, "LocalRepository already contains package {0}, installing files.", packageId) + let latest = + manager.SourceRepository.FindPackage + (packageId, VersionSpec(), false, false) + let ok, package = + manager.LocalRepository.TryFindPackage(latest.Id, latest.Version) + if ok then + manager.Logger.Log + (MessageLevel.Info, + "LocalRepository already contains package {0}, installing files.", + packageId) let project = ProjectSystem(projectName) :> IProjectSystem InstallToPackagesConfigFile package project - AddFilesToProj (manager.PathResolver.GetInstallPath package) package project - else - manager.InstallPackage packageId + AddFilesToProj (manager.PathResolver.GetInstallPath package) package + project + else manager.InstallPackage packageId -let RestoreReferences projectName = +let RestoreReferences projectName = let manager = GetRawManager projectName let packages = getRestorePackages projectName - packages - |> Seq.iter (fun p -> manager.InstallPackage(p.Id, p.Version, false, true)) + packages + |> Seq.iter(fun p -> manager.InstallPackage(p.Id, p.Version, false, true)) -let RemoveReference projectName (packageId : string) = +let RemoveReference projectName (packageId : string) = let manager = GetManager projectName let restorePackages = getRestorePackages projectName let version = (Seq.find (fun p -> p.Id = packageId) restorePackages).Version diff --git a/NuGetPlus.Core/ProjectSystem.fs b/NuGetPlus.Core/ProjectSystem.fs index 42438ca..165f928 100644 --- a/NuGetPlus.Core/ProjectSystem.fs +++ b/NuGetPlus.Core/ProjectSystem.fs @@ -1,5 +1,6 @@ [] module NuGetPlus.ProjectSystem + open System open System.IO open System.Collections.Generic @@ -7,70 +8,103 @@ open System.Reflection open Microsoft.Build.Evaluation open NuGet -let TryGetProject projectFile = - ProjectCollection.GlobalProjectCollection.GetLoadedProjects(projectFile) - |> Seq.tryFind (fun p -> p.FullPath = projectFile) +let TryGetProject projectFile = + ProjectCollection.GlobalProjectCollection.GetLoadedProjects(projectFile) + |> Seq.tryFind(fun p -> p.FullPath = projectFile) -type ProjectSystem (projectFile : string) = +type ProjectSystem(projectFile : string) = inherit PhysicalFileSystem(Path.GetDirectoryName(projectFile)) - let project = + + let project = match TryGetProject projectFile with | Some project -> project | None -> Project(projectFile) + let projectName = Path.GetFileNameWithoutExtension <| project.FullPath - let framework = new Runtime.Versioning.FrameworkName(project.GetPropertyValue("TargetFrameworkMoniker")) - let GetReference path = - let name = Path.GetFileNameWithoutExtension path - project.GetItems("Reference") - |> Seq.filter (fun i -> i.EvaluatedInclude.StartsWith(name, StringComparison.OrdinalIgnoreCase)) - |> Seq.tryFind (fun i -> AssemblyName(i.EvaluatedInclude).Name.Equals(name, StringComparison.OrdinalIgnoreCase)) + let framework = + new Runtime.Versioning.FrameworkName(project.GetPropertyValue + ("TargetFrameworkMoniker")) + + let GetReference path = + let name = Path.GetFileNameWithoutExtension path + project.GetItems("Reference") + |> Seq.filter + (fun i -> + i.EvaluatedInclude.StartsWith + (name, StringComparison.OrdinalIgnoreCase)) + |> Seq.tryFind + (fun i -> + AssemblyName(i.EvaluatedInclude) + .Name.Equals(name, StringComparison.OrdinalIgnoreCase)) + interface IProjectSystem with - member x.TargetFramework - with get () = framework - member x.ProjectName - with get () = projectName - member x.AddReference (path, stream) = + member x.TargetFramework with get () = framework + member x.ProjectName with get () = projectName + + member x.AddReference(path, stream) = let fullPath = PathUtility.GetAbsolutePath(x.Root, path) - let relPath = PathUtility.GetRelativePath(project.FullPath, fullPath) + let relPath = + PathUtility.GetRelativePath(project.FullPath, fullPath) let includeName = Path.GetFileNameWithoutExtension fullPath - project.AddItem("Reference", includeName, [| KeyValuePair("HintPath", relPath) |]) |> ignore - project.Save () - member x.AddFrameworkReference name = + project.AddItem + ("Reference", includeName, [|KeyValuePair("HintPath", relPath)|]) + |> ignore + project.Save() + + member x.AddFrameworkReference name = project.AddItem("Reference", name) |> ignore - project.Save () - member x.ReferenceExists path = + project.Save() + + member x.ReferenceExists path = match GetReference path with | Some _ -> true | None -> false - member x.RemoveReference name = + + member x.RemoveReference name = match GetReference name with - | Some i -> + | Some i -> project.RemoveItem(i) |> ignore project.Save() | None -> () - member x.IsSupportedFile path = - true - member x.ResolvePath path = - path - member x.IsBindingRedirectSupported - with get () = true - member x.AddImport ((targetPath : string), location) = + + member x.IsSupportedFile path = true + member x.ResolvePath path = path + member x.IsBindingRedirectSupported with get () = true + + member x.AddImport((targetPath : string), location) = if project.Xml.Imports = null - || project.Xml.Imports |> Seq.forall (fun import -> not <| targetPath.Equals(import.Project, StringComparison.OrdinalIgnoreCase)) then - project.Xml.AddImport(targetPath) |> ignore - project.ReevaluateIfNecessary () - project.Save () - member x.RemoveImport (targetPath : string) = - match project.Xml.Imports |> Seq.tryFind (fun import -> targetPath.Equals(import.Project, StringComparison.OrdinalIgnoreCase)) with + || project.Xml.Imports + |> Seq.forall + (fun import -> + not + <| targetPath.Equals + (import.Project, + StringComparison.OrdinalIgnoreCase)) then + project.Xml.AddImport(targetPath) |> ignore + project.ReevaluateIfNecessary() + project.Save() + + member x.RemoveImport(targetPath : string) = + match project.Xml.Imports + |> Seq.tryFind + (fun import -> + targetPath.Equals + (import.Project, + StringComparison.OrdinalIgnoreCase)) with | None -> () | Some i -> project.Xml.RemoveChild(i) - project.ReevaluateIfNecessary () + project.ReevaluateIfNecessary() project.Save() - member x.FileExistsInProject (path : string) = - project.Items - |> Seq.exists (fun i -> i.EvaluatedInclude.Equals(path, StringComparison.OrdinalIgnoreCase) && (String.IsNullOrEmpty(i.ItemType) || i.ItemType.[0] <> '_')) - + + member x.FileExistsInProject(path : string) = + project.Items + |> Seq.exists + (fun i -> + i.EvaluatedInclude.Equals + (path, StringComparison.OrdinalIgnoreCase) + && (String.IsNullOrEmpty(i.ItemType) + || i.ItemType.[0] <> '_')) + interface IPropertyProvider with - member x.GetPropertyValue name = - project.GetPropertyValue(name) :> obj + member x.GetPropertyValue name = project.GetPropertyValue(name) :> obj \ No newline at end of file diff --git a/NuGetPlus.Core/XmlTransformer.fs b/NuGetPlus.Core/XmlTransformer.fs index c9ea8f3..417e7af 100644 --- a/NuGetPlus.Core/XmlTransformer.fs +++ b/NuGetPlus.Core/XmlTransformer.fs @@ -1,30 +1,42 @@ [] module XmlTransformer + open System open System.Collections.Generic open System.IO open System.Xml.Linq open NuGet -type XmlTransformer () = - let (configMappings : IDictionary>) = dict [(XName.Get "configSections", Action(fun parent element -> parent.AddFirst(element)))] +type XmlTransformer() = + let (configMappings : IDictionary>) = + dict + [(XName.Get "configSections", + + Action + (fun parent element -> parent.AddFirst(element)))] interface IPackageFileTransformer with - member x.TransformFile(file, targetPath, projectSystem) = + + member x.TransformFile(file, targetPath, projectSystem) = let pp = Preprocessor() :> IPackageFileTransformer pp.TransformFile(file, targetPath, projectSystem) let reader = new StreamReader(projectSystem.OpenFile(targetPath)) let xml = XElement.Parse(reader.ReadToEnd()) reader.Dispose() - let doc = + let doc = match projectSystem.FileExists targetPath with - | true -> + | true -> use configStream = projectSystem.OpenFile(targetPath) XDocument.Load(configStream, LoadOptions.PreserveWhitespace) - | false -> + | false -> let xDoc = XDocument(XElement(xml.Name)) - projectSystem.AddFile(targetPath, fun (stream : Stream) -> xDoc.Save(stream)) + projectSystem.AddFile + (targetPath, fun (stream : Stream) -> xDoc.Save(stream)) xDoc doc.Root.MergeWith(xml, configMappings) |> ignore - projectSystem.AddFile(targetPath, fun (stream : Stream) -> doc.Save(stream)) - member x.RevertFile(file, targetPath, matchingFiles, projectSystem) = - raise <| NotImplementedException("RevertFile for XmlTransformer not implemented") \ No newline at end of file + projectSystem.AddFile + (targetPath, fun (stream : Stream) -> doc.Save(stream)) + + member x.RevertFile(file, targetPath, matchingFiles, projectSystem) = + raise + <| NotImplementedException + ("RevertFile for XmlTransformer not implemented") \ No newline at end of file diff --git a/NuGetPlus.TickSpec.Tests/Fixtures.fs b/NuGetPlus.TickSpec.Tests/Fixtures.fs index a8f84f5..68e4741 100644 --- a/NuGetPlus.TickSpec.Tests/Fixtures.fs +++ b/NuGetPlus.TickSpec.Tests/Fixtures.fs @@ -5,22 +5,26 @@ open System.IO open System.Reflection open TickSpec -let assembly = Assembly.GetExecutingAssembly() +let assembly = Assembly.GetExecutingAssembly() let definitions = new StepDefinitions(assembly) /// Inherit from FeatureFixture to define a feature fixture [] [] -type FeatureFixture (source:string) = - [] - [] - member this.TestScenario (scenario:Scenario) = - if scenario.Tags |> Seq.exists ((=) "ignore") then - raise (new IgnoreException("Ignored: " + scenario.Name)) +type FeatureFixture(source : string) = + + [][] + member this.TestScenario(scenario : Scenario) = + if scenario.Tags |> Seq.exists((=) "ignore") then + raise(new IgnoreException("Ignored: " + scenario.Name)) scenario.Action.Invoke() - member this.Scenarios = - let s = File.OpenText(Path.Combine(@"..\..\",source)) - definitions.GenerateScenarios(source,s) + + member this.Scenarios = + let s = File.OpenText(Path.Combine(@"..\..\", source)) + definitions.GenerateScenarios(source, s) -type ProjectFixture () = inherit FeatureFixture("ProjectFeature.txt") -type SolutionFixture () = inherit FeatureFixture("SolutionFeature.txt") \ No newline at end of file +type ProjectFixture() = + inherit FeatureFixture("ProjectFeature.txt") + +type SolutionFixture() = + inherit FeatureFixture("SolutionFeature.txt") \ No newline at end of file diff --git a/NuGetPlus.TickSpec.Tests/ProjectStepDefinitions.fs b/NuGetPlus.TickSpec.Tests/ProjectStepDefinitions.fs index e8b379e..83897a7 100644 --- a/NuGetPlus.TickSpec.Tests/ProjectStepDefinitions.fs +++ b/NuGetPlus.TickSpec.Tests/ProjectStepDefinitions.fs @@ -1,4 +1,4 @@ -[] +[] module NuGetPlus.TickSpec.Tests.ProjectDefinitions open TickSpec @@ -7,138 +7,172 @@ open System open System.IO open Microsoft.Build.Evaluation open NuGetPlus.ProjectManagement -type State = - { - project : FileInfo - package : string - expectedVersion : Option - } -let mutable state = { project = FileInfo("."); package = ""; expectedVersion = None } +type State = + { project : FileInfo; + package : string; + expectedVersion : Option } -let [] TearDownScenario () = +let mutable state = + { project = FileInfo("."); + package = ""; + expectedVersion = None } + +[] +let TearDownScenario() = let projFiles = workingDir.GetFileSystemInfos "*.*proj" - projFiles |> Seq.iter (fun proj -> ProjectCollection.GlobalProjectCollection.GetLoadedProjects(proj.FullName) |> Seq.iter ProjectCollection.GlobalProjectCollection.UnloadProject) - if workingDir.Exists then + projFiles + |> Seq.iter + (fun proj -> + ProjectCollection.GlobalProjectCollection.GetLoadedProjects + (proj.FullName) + |> Seq.iter + ProjectCollection.GlobalProjectCollection.UnloadProject) + if workingDir.Exists then // This often throws a random error as it tries to delete the directory // before file deletion has finished. So we try again. - try + try workingDir.Delete(true) with - | _ -> + | _ -> Threading.Thread.Sleep(200) workingDir.Delete(true) workingDir.Create() - state <- { project = FileInfo("."); package = ""; expectedVersion = None } + state <- { project = FileInfo("."); + package = ""; + expectedVersion = None } -let constructWorkingProject projType hasPackages destinationDir shared = - let midFix = +let constructWorkingProject projType hasPackages destinationDir shared = + let midFix = match hasPackages with | "packages" -> ".WithPackages." | "no packages" -> ".NoPackages." | _ -> failwith "Unknown package option" let example = testProjectDir.GetFiles("*.*", SearchOption.AllDirectories) - |> Seq.filter (fun fi -> fi.Name = projType + midFix + (projType.ToLower())) + |> Seq.filter + (fun fi -> fi.Name = projType + midFix + (projType.ToLower())) |> Seq.head - ensureWorkingDirectory () + ensureWorkingDirectory() let destination = Path.Combine(destinationDir, example.Name) let projDir = DirectoryInfo(Path.GetDirectoryName destination) - if projDir.Exists then - projDir.Delete(true) + if projDir.Exists then projDir.Delete(true) projDir.Create() - if shared then - let nugetConfig = FileInfo(Path.Combine(testProjectDir.FullName, "nuget.config")) + if shared then + let nugetConfig = + FileInfo(Path.Combine(testProjectDir.FullName, "nuget.config")) let destination = Path.Combine(projDir.Parent.FullName, "nuget.config") - if not <| File.Exists destination then + if not <| File.Exists destination then nugetConfig.CopyTo(destination) |> ignore - else - let nugetConfig = FileInfo(Path.Combine(testProjectDir.FullName, "nuget.config")) - nugetConfig.CopyTo(Path.Combine(projDir.FullName, "nuget.config")) |> ignore - example.Directory.GetFiles() - |> Seq.iter (fun fi -> fi.CopyTo(Path.Combine(Path.GetDirectoryName destination, fi.Name)) |> ignore) + else + let nugetConfig = + FileInfo(Path.Combine(testProjectDir.FullName, "nuget.config")) + nugetConfig.CopyTo(Path.Combine(projDir.FullName, "nuget.config")) + |> ignore + example.Directory.GetFiles() + |> Seq.iter + (fun fi -> + fi.CopyTo + (Path.Combine(Path.GetDirectoryName destination, fi.Name)) + |> ignore) state <- { state with project = FileInfo(destination) } -let [] ``a (\w*) with (packages|no packages)`` (projType:string) (hasPackages:string) = - let destinationDir = Path.Combine(workingDir.FullName, Guid.NewGuid().ToString()) +[] +let ``a (\w*) with (packages|no packages)`` (projType : string) + (hasPackages : string) = + let destinationDir = + Path.Combine(workingDir.FullName, Guid.NewGuid().ToString()) constructWorkingProject projType hasPackages destinationDir false -let [] ``a (|restored )(\w*) (\w*) with (packages|no packages)`` (restored:string) (ordinal:string) (projType:string) (hasPackages:string) = +[] +let ``a (|restored )(\w*) (\w*) with (packages|no packages)`` (restored : string) + (ordinal : string) (projType : string) (hasPackages : string) = let destinationDir = Path.Combine(workingDir.FullName, ordinal) constructWorkingProject projType hasPackages destinationDir true - if restored = "restored " then - RestoreReferences state.project.FullName + if restored = "restored " then RestoreReferences state.project.FullName -let [] ``I install (\S*) version (\S*)`` (packageId:string) (version:string) = - state <- { state with package = packageId; expectedVersion = Some version } - InstallReferenceOfSpecificVersion state.project.FullName packageId (NuGet.SemanticVersion(version)) +[] +let ``I install (\S*) version (\S*)`` (packageId : string) (version : string) = + state <- { state with package = packageId; + expectedVersion = Some version } + InstallReferenceOfSpecificVersion state.project.FullName packageId + (NuGet.SemanticVersion(version)) -let [] ``I install (\S*)$`` (packageId:string) = +[] +let ``I install (\S*)$``(packageId : string) = state <- { state with package = packageId } InstallReference state.project.FullName packageId -let [] ``remove (.*)`` (packageId:string) = +[] +let ``remove (.*)``(packageId : string) = state <- { state with package = packageId } RemoveReference state.project.FullName packageId -let [] ``I restore a project with (.*)`` (packageId:string) = +[] +let ``I restore a project with (.*)``(packageId : string) = state <- { state with package = packageId } RestoreReferences state.project.FullName -let [] ``I update (\S*)$`` (packageId:string) = +[] +let ``I update (\S*)$``(packageId : string) = state <- { state with expectedVersion = None } UpdateReference state.project.FullName packageId - -let [] ``I update (\S*) to version (.*)$`` (packageId : string) (version : string) = + +[] +let ``I update (\S*) to version (.*)$`` (packageId : string) (version : string) = state <- { state with expectedVersion = Some version } - UpdateReferenceToSpecificVersion state.project.FullName packageId (NuGet.SemanticVersion(version)) - -let [] ``the package (should|should not) be installed in the (right|shared) directory`` (should : string) (shared : string) = - let packagesDir = + UpdateReferenceToSpecificVersion state.project.FullName packageId + (NuGet.SemanticVersion(version)) + +[] +let ``the package (should|should not) be installed in the (right|shared) directory`` (should : string) + (shared : string) = + let packagesDir = match shared with - | "right" -> - DirectoryInfo(Path.Combine(state.project.Directory.FullName, "packages")) - | "shared" -> - DirectoryInfo(Path.Combine(state.project.Directory.Parent.FullName, "packages")) + | "right" -> + DirectoryInfo + (Path.Combine(state.project.Directory.FullName, "packages")) + | "shared" -> + DirectoryInfo + (Path.Combine + (state.project.Directory.Parent.FullName, "packages")) | _ -> failwith "Unknown local repository type" - if packagesDir.Exists then + if packagesDir.Exists then let isDir = match state.expectedVersion with - | None -> - packagesDir.GetDirectories() |> Seq.exists (fun di -> di.Name.StartsWith state.package) - | Some version -> - packagesDir.GetDirectories() |> Seq.exists (fun di -> di.Name = state.package + "." + version) + | None -> + packagesDir.GetDirectories() + |> Seq.exists(fun di -> di.Name.StartsWith state.package) + | Some version -> + packagesDir.GetDirectories() + |> Seq.exists(fun di -> di.Name = state.package + "." + version) match should with | "should" -> Assert.IsTrue isDir | "should not" -> Assert.IsFalse isDir | _ -> failwith "Unknown should option" - else + else match should with | "should" -> Assert.Fail() | "should not" -> Assert.IsTrue true | _ -> failwith "Unknown should option" -let [] ``the reference (should|should not) be added to the project file`` (should : string) = - let content = - using - (state.project.OpenText()) - (fun proj -> proj.ReadToEnd()) - content.Contains(state.package) - |> - match should with - | "should" -> Assert.IsTrue - | "should not" -> Assert.IsFalse - | _ -> failwith "Unknown should option" +[] +let ``the reference (should|should not) be added to the project file``(should : string) = + let content = + using (state.project.OpenText()) (fun proj -> proj.ReadToEnd()) + content.Contains(state.package) |> match should with + | "should" -> Assert.IsTrue + | "should not" -> Assert.IsFalse + | _ -> failwith "Unknown should option" -let [] ``the package (should|should not) be added to the packages.config file`` (should : string) = - let packagesConfig = FileInfo(Path.Combine(state.project.Directory.FullName, "packages.config")) - let content = - using - (packagesConfig.OpenText()) - (fun config -> config.ReadToEnd()) - content.Contains(state.package) - |> - match should with - | "should" -> Assert.IsTrue - | "should not" -> Assert.IsFalse - | _ -> failwith "Unknown should option" \ No newline at end of file +[] +let ``the package (should|should not) be added to the packages.config file``(should : string) = + let packagesConfig = + FileInfo + (Path.Combine(state.project.Directory.FullName, "packages.config")) + let content = + using (packagesConfig.OpenText()) (fun config -> config.ReadToEnd()) + content.Contains(state.package) |> match should with + | "should" -> Assert.IsTrue + | "should not" -> Assert.IsFalse + | _ -> failwith "Unknown should option" \ No newline at end of file diff --git a/NuGetPlus.TickSpec.Tests/SolutionStepDefinitions.fs b/NuGetPlus.TickSpec.Tests/SolutionStepDefinitions.fs index c0df279..a8044f7 100644 --- a/NuGetPlus.TickSpec.Tests/SolutionStepDefinitions.fs +++ b/NuGetPlus.TickSpec.Tests/SolutionStepDefinitions.fs @@ -78,19 +78,25 @@ let constructWorkingSolution name destinationDir shared = |> ignore) state <- { state with Solution = example } -let [] ``a solution called (.*)`` (solution : string) = - constructWorkingSolution solution (Path.Combine(workingDir.FullName, "TestSolution")) false +[] +let ``a solution called (.*)``(solution : string) = + constructWorkingSolution solution + (Path.Combine(workingDir.FullName, "TestSolution")) false -let [] ``I ask for the project list`` () = +[] +let ``I ask for the project list``() = state <- { state with ProjectList = GetProjects state.Solution.FullName } -let [] ``the project list should contain (.*)`` (projectName : string) = +[] +let ``the project list should contain (.*)``(projectName : string) = state.ProjectList - |> Seq.map (fun name -> FileInfo(name).Name) + |> Seq.map(fun name -> FileInfo(name).Name) |> should contain projectName -let [] ``(.*) should be in a directory called (.*)`` (projectName : string) (directoryName : string) = +[] +let ``(.*) should be in a directory called (.*)`` (projectName : string) + (directoryName : string) = state.ProjectList - |> Seq.find (fun name -> name.Contains(projectName)) + |> Seq.find(fun name -> name.Contains(projectName)) |> fun p -> FileInfo(p).Directory.Name |> should equal directoryName \ No newline at end of file diff --git a/NuGetPlus.TickSpec.Tests/TestUtilities.fs b/NuGetPlus.TickSpec.Tests/TestUtilities.fs index 38cca57..e257538 100644 --- a/NuGetPlus.TickSpec.Tests/TestUtilities.fs +++ b/NuGetPlus.TickSpec.Tests/TestUtilities.fs @@ -1,24 +1,24 @@ [] module NuGetPlus.TickSpec.Tests.TestUtilities + open System open System.IO -let testProjectDir = +let testProjectDir = let TestProjectDirName = "TestProjects" - let rec inner (dir : DirectoryInfo) = - if Seq.length <| dir.EnumerateDirectories(TestProjectDirName) > 0 then + let rec inner(dir : DirectoryInfo) = + if Seq.length <| dir.EnumerateDirectories(TestProjectDirName) > 0 then DirectoryInfo(Path.Combine(dir.FullName, TestProjectDirName)) - else - if dir.Parent = null then - failwith "Could not find the TestProjects" - else - inner dir.Parent - inner (DirectoryInfo(".")) + else if dir.Parent = null then + failwith "Could not find the TestProjects" + else inner dir.Parent + inner(DirectoryInfo(".")) -let workingDir = DirectoryInfo(Path.Combine(testProjectDir.FullName, "WorkingDirectory")) +let workingDir = + DirectoryInfo(Path.Combine(testProjectDir.FullName, "WorkingDirectory")) -let ensureWorkingDirectory () = - if not workingDir.Exists then - workingDir.Create() +let ensureWorkingDirectory() = + if not workingDir.Exists then workingDir.Create() -let packagesDir = DirectoryInfo(Path.Combine(testProjectDir.FullName, "packages")) +let packagesDir = + DirectoryInfo(Path.Combine(testProjectDir.FullName, "packages")) \ No newline at end of file