private static PackageManager CreatePackageManager(DirectoryPath packagePath) { var repository = PackageRepositoryFactory.Default.CreateRepository("https://packages.nuget.org/api/v2"); var resolver = new PackagePathResolver(packagePath); var fileSystem = new PhysicalFileSystem(packagePath.FullPath); return new PackageManager(repository, resolver, fileSystem); }
public static void GitPush( this ICakeContext context, DirectoryPath repositoryDirectoryPath ) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (repositoryDirectoryPath == null) { throw new ArgumentNullException(nameof(repositoryDirectoryPath)); } var workFullDirectoryPath = repositoryDirectoryPath.MakeAbsolute(context.Environment); if (!context.FileSystem.Exist(workFullDirectoryPath)) { throw new DirectoryNotFoundException($"Failed to find workDirectoryPath: {workFullDirectoryPath}"); } context.UseRepository( repositoryDirectoryPath, repository => repository.Network.Push( repository.Branches ) ); }
public static void GitRemove( this ICakeContext context, DirectoryPath repositoryDirectoryPath, bool removeFromWorkingDirectory, params FilePath[] filePaths ) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (repositoryDirectoryPath == null) { throw new ArgumentNullException(nameof(repositoryDirectoryPath)); } context.UseRepository( repositoryDirectoryPath, repository => repository.Remove( filePaths.ToRelativePathStrings(context, repositoryDirectoryPath), removeFromWorkingDirectory, new ExplicitPathsOptions () ) ); }
public IEnumerable<IFile> Install(PackageDefinition package, DirectoryPath root) { var result = new List<FilePath>(); var paths = new FilePathCollection(PathComparer.Default); // InstallPackage the package. var packagePath = InstallPackage(package, root); var packageDirectory = _fileSystem.GetDirectory(packagePath); if (package.Filters != null && package.Filters.Count > 0) { // Get all files matching the filters. foreach (var filter in package.Filters) { var pattern = string.Concat(packagePath.FullPath, "/", filter.TrimStart('/', '\\')); paths.Add(_globber.GetFiles(pattern)); } } else { // Do a recursive search in the package directory. paths.Add(packageDirectory. GetFiles("*", SearchScope.Recursive) .Select(file => file.Path)); } if (paths.Count > 0) { result.AddRange(paths); } return result.Select(path => _fileSystem.GetFile(path)); }
public static GitCommit GitCommit( this ICakeContext context, DirectoryPath repositoryDirectoryPath, string name, string email, string message ) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (repositoryDirectoryPath == null) { throw new ArgumentNullException(nameof(repositoryDirectoryPath)); } return context.UseRepository( repositoryDirectoryPath, repository => new GitCommit( repository.Commit( message, new Signature(name, email, DateTimeOffset.Now), new Signature(name, email, DateTimeOffset.Now), new CommitOptions() ) ) ); }
public static void GitCheckout( this ICakeContext context, DirectoryPath repositoryDirectoryPath, string committishOrBranchSpec, params FilePath[] filePaths ) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (string.IsNullOrWhiteSpace(committishOrBranchSpec)) { throw new ArgumentNullException(nameof(committishOrBranchSpec)); } if (repositoryDirectoryPath == null) { throw new ArgumentNullException(nameof(repositoryDirectoryPath)); } context.UseRepository( repositoryDirectoryPath, repository => repository.CheckoutPaths( committishOrBranchSpec, filePaths.ToRelativePathStrings(context, repositoryDirectoryPath), new CheckoutOptions { CheckoutModifiers = CheckoutModifiers.Force } ) ); }
public static DirectoryPath GitClone( this ICakeContext context, string sourceUrl, DirectoryPath workDirectoryPath ) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (string.IsNullOrWhiteSpace(sourceUrl)) { throw new ArgumentNullException(nameof(sourceUrl)); } if (workDirectoryPath == null) { throw new ArgumentNullException(nameof(workDirectoryPath)); } var workFullDirectoryPath = workDirectoryPath.MakeAbsolute(context.Environment); if (!context.FileSystem.Exist(workFullDirectoryPath)) { throw new DirectoryNotFoundException($"Failed to find workDirectoryPath: {workFullDirectoryPath}"); } return Repository.Clone(sourceUrl, workFullDirectoryPath.FullPath); }
internal static DirectoryPath MakeRelativePath(this DirectoryPath directoryPath, ICakeEnvironment environment, DirectoryPath rootDirectoryPath) { if (directoryPath == null) { throw new ArgumentNullException(nameof(directoryPath)); } if (environment == null) { throw new ArgumentNullException(nameof(environment)); } if (rootDirectoryPath == null) { throw new ArgumentNullException(nameof(rootDirectoryPath)); } var dirUri = new Uri(directoryPath.MakeAbsolute(environment).FullPath); var rootUri = new Uri($"{rootDirectoryPath.MakeAbsolute(environment).FullPath}/"); var relativeUri = rootUri.MakeRelativeUri(dirUri); var relativePath = Uri.UnescapeDataString(relativeUri.ToString()); var relativeDirectoryPath = new DirectoryPath(relativePath); return relativeDirectoryPath; }
/// <summary> /// /// </summary> /// <param name="appPath"></param> public AppPathBasedIISExpressSettings(DirectoryPath appPath) { if (appPath == null) throw new ArgumentNullException("appPath"); AppPath = appPath; PortNumber = 8080; ClrVersion = ClrVersion.Version40; }
public void GetAllPackageReferencesForThisProject() { var d = new DirectoryPath("../../"); var packageReferences = context.CakeContext.GetPackageReferences(d); Assert.IsNotEmpty(packageReferences); }
public static void GitCheckout( this ICakeContext context, DirectoryPath repositoryDirectoryPath, params FilePath[] filePaths ) { context.GitCheckout(repositoryDirectoryPath, "HEAD", filePaths); }
private static IEnumerable<IFile> Install(NuGetConfiguration configuration, DirectoryPath appDataPath) { var fileSystem = new FileSystem(); var environment = new CakeEnvironment(); var globber = new Globber(fileSystem, environment); var installer = new NuGetInstaller(fileSystem, globber); return installer.Install(configuration, appDataPath, true); }
// ReSharper restore MemberCanBePrivate.Global // ReSharper restore UnusedAutoPropertyAccessor.Global /// <summary> /// Sync two folders content /// </summary> /// <param name="source">The source directory path.</param> // ReSharper disable once UnusedMember.Global public void Sync(DirectoryPath source) { if (source == null) { throw new ArgumentNullException(nameof(source)); } Sync(source, Deployment.Target); }
public void PackageComponentTest () { var yaml = new DirectoryPath ("./TestProjects/ComponentPackage/"); context.CakeContext.PackageComponent (yaml, new XamarinComponentSettings { ToolPath = "./TestProjects/tools/xamarin-component.exe" }); Assert.IsTrue (context.CakeContext.FileExists ("./TestProjects/ComponentPackage/testcomponent-1.0.0.0.xam")); }
public bool Generate(DirectoryPath path) { var version = _prober.GetVersion("Cake"); if (string.IsNullOrWhiteSpace(version)) { _log.Error("Could not resolve latest package version."); return false; } return Generate(path, version); }
public static void CMake(this ICakeContext context, DirectoryPath sourcePath, CMakeSettings settings) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var runner = new CMakeRunner(context.FileSystem, context.Environment, context.ProcessRunner, context.Globber); runner.Run(sourcePath, settings); }
public static void AliaSql(this ICakeContext context, string command, string connectionString, string databaseName, DirectoryPath scriptsPath) { AliaSql(context, new AliaSqlSettings { Command = command, ConnectionString = connectionString, DatabaseName = databaseName, ScriptsFolder = scriptsPath }); }
public BlogIndex Parse(DirectoryPath path) { var directory = _fileSystem.GetDirectory(path); if (!directory.Exists) { return new BlogIndex(Enumerable.Empty<BlogPost>()); } var posts = new List<BlogPost>(); var files = directory.GetFiles("*", SearchScope.Current); foreach (var file in files) { var filename = BlogFilename.Parse(file.Path); if (filename != null) { // Read the file. var content = _parser.Parse(file.Path); if (!content.FrontMatter.ContainsKey("content-type")) { content.FrontMatter.Add("content-type", "markdown"); } // Process the content. var body = _processor.PreProcess(content.Body); body = _converter.ConvertToHtml(content, body); body = _processor.PostProcess(body) ?? body; // Get the excerpts. var excerpts = _converter.ConvertToHtml(content, content.Excerpt); // Rewrite the feed body. // This is kind of a hack, but we need to make sure that all links are absolute. var feedBody = RewriteRelativeLinks(body); var author = content.GetFrontMatter("author"); // Add the blog post. posts.Add(new BlogPost(filename.Slug, content.GetFrontMatter("title"), body, feedBody, excerpts, filename.PostedAt, GetCategories(content), author == null ? "Cake Team" : author)); } } // Hack. Don't judge me... :) var maxDate = posts.Max(x => x.PostedAt); var lastPost = posts.FirstOrDefault(x => x.PostedAt == maxDate); if (lastPost != null) { lastPost.IsLatest = true; } return new BlogIndex(posts); }
public void Setup () { context = new FakeCakeContext (); var dp = new DirectoryPath ("./testdata"); var d = context.CakeContext.FileSystem.GetDirectory (dp); if (d.Exists) d.Delete (true); d.Create (); }
public static void AliaSql(this ICakeContext context, string command, string connectionString, string databaseName, DirectoryPath scriptsPath, string username, string password) { AliaSql(context, new AliaSqlSettings { Command = command, ConnectionString = connectionString, DatabaseName = databaseName, ScriptsFolder = scriptsPath, UserName = username, Password = password }); }
/// <summary> /// Sets the working directory for the process to be started. /// </summary> /// <param name="settings">The process settings.</param> /// <param name="path">The working directory for the process to be started.</param> /// <returns>The same <see cref="AdvProcessSettings"/> instance so that multiple calls can be chained.</returns> public static AdvProcessSettings UseWorkingDirectory(this AdvProcessSettings settings, DirectoryPath path) { if (settings == null) { throw new ArgumentNullException("settings"); } if (path == null) { throw new ArgumentNullException("path"); } settings.WorkingDirectory = path; return settings; }
public static DirectoryPath GitClone( this ICakeContext context, string sourceUrl, DirectoryPath workDirectoryPath, string username, string password ) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (string.IsNullOrWhiteSpace(sourceUrl)) { throw new ArgumentNullException(nameof(sourceUrl)); } if (string.IsNullOrWhiteSpace(username)) { throw new ArgumentNullException(nameof(username)); } if (string.IsNullOrWhiteSpace(password)) { throw new ArgumentNullException(nameof(password)); } if (workDirectoryPath == null) { throw new ArgumentNullException(nameof(workDirectoryPath)); } var workFullDirectoryPath = workDirectoryPath.MakeAbsolute(context.Environment); if (!context.FileSystem.Exist(workFullDirectoryPath)) { throw new DirectoryNotFoundException($"Failed to find workDirectoryPath: {workFullDirectoryPath}"); } var options = new CloneOptions { CredentialsProvider = (url, user, cred) => new UsernamePasswordCredentials {Username = username, Password = password} }; return Repository.Clone(sourceUrl, workFullDirectoryPath.FullPath, options); }
public FakeCakeContext () { testsDir = new DirectoryPath ( System.IO.Path.GetFullPath (AppDomain.CurrentDomain.BaseDirectory)); var fileSystem = new FileSystem (); var environment = new CakeEnvironment (); var globber = new Globber (fileSystem, environment); log = new FakeLog (); var args = new FakeCakeArguments (); var processRunner = new ProcessRunner (environment, log); var registry = new WindowsRegistry (); context = new CakeContext (fileSystem, environment, globber, log, args, processRunner, registry); context.Environment.WorkingDirectory = testsDir; }
private TopicTree Read(DirectoryPath root, Stream stream) { var result = new List<TopicSection>(); var reader = new XmlTextReader(stream); while (reader.Read()) { if (reader.IsStartElement() && reader.Name == "section") { var section = ReadSection(reader, root); if (section != null) { result.Add(section); } } } return new TopicTree(result); }
public DirectoryPath InstallPackage(PackageDefinition package, DirectoryPath root) { var packagePath = root.Combine("libs"); if (!_fileSystem.Exist(packagePath)) { _fileSystem.GetDirectory(packagePath).Create(); } if (!_fileSystem.Exist(packagePath.Combine(package.PackageName))) { var packageManager = CreatePackageManager(packagePath); packageManager.InstallPackage(package.PackageName); } // Return the installation directory. return packagePath.Combine(package.PackageName); }
/// <summary> /// Sync two folders content /// </summary> /// <param name="source">The source directory path.</param> /// <param name="target">The target directory path.</param> // ReSharper disable once UnusedMember.Global // ReSharper disable once MemberCanBePrivate.Global public void Sync(DirectoryPath source, DirectoryPath target) { if (source == null) { throw new ArgumentNullException(nameof(source)); } if (target == null) { throw new ArgumentNullException(nameof(target)); } Sync(source, target, new KuduSyncSettings { PreviousManifest = Deployment.PreviousManifest, NextManifest = Deployment.NextManifest }); }
public FakeCakeContext () { testsDir = new DirectoryPath ( System.IO.Path.GetFullPath (AppDomain.CurrentDomain.BaseDirectory)); var fileSystem = new FileSystem (); var environment = new CakeEnvironment (new CakePlatform (), new CakeRuntime ()); var globber = new Globber (fileSystem, environment); log = new FakeLog (); var args = new FakeCakeArguments (); var processRunner = new ProcessRunner (environment, log); var registry = new WindowsRegistry (); var toolRepo = new ToolRepository (environment); var config = new Core.Configuration.CakeConfigurationProvider (fileSystem, environment).CreateConfiguration (testsDir, new Dictionary<string, string> ()); var toolResolutionStrategy = new ToolResolutionStrategy (fileSystem, environment, globber, config); var toolLocator = new ToolLocator (environment, toolRepo, toolResolutionStrategy); context = new CakeContext (fileSystem, environment, globber, log, args, processRunner, registry, toolLocator); context.Environment.WorkingDirectory = testsDir; }
public BlogIndex Parse(DirectoryPath path) { var directory = _fileSystem.GetDirectory(path); if (!directory.Exists) { return new BlogIndex(Enumerable.Empty<BlogPost>()); } var posts = new List<BlogPost>(); var files = directory.GetFiles("*", SearchScope.Current); foreach (var file in files) { var filename = BlogFilename.Parse(file.Path); if (filename != null) { // Parse the file. var content = _parser.Parse(file.Path); if (!content.FrontMatter.ContainsKey("content-type")) { content.FrontMatter.Add("content-type", "markdown"); } // Process the content. var body = _converter.ConvertToHtml(content, content.Body); body = _processor.Process(body) ?? body; // Get the excerpts. var excerpts = _converter.ConvertToHtml(content, content.Excerpt); // Rewrite the feed body. // This is kind of a hack, but we need to make sure that all links are absolute. var feedBody = RewriteRelativeLinks(body); // Add the blog post. posts.Add(new BlogPost(filename.Slug, content.GetFrontMatter("title"), body, feedBody, excerpts, filename.PostedAt, GetCategories(content))); } } return new BlogIndex(posts); }
public static void GitPush( this ICakeContext context, DirectoryPath repositoryDirectoryPath, string username, string password ) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (repositoryDirectoryPath == null) { throw new ArgumentNullException(nameof(repositoryDirectoryPath)); } var repositoryFullDirectoryPath = repositoryDirectoryPath.MakeAbsolute(context.Environment); if (!context.FileSystem.Exist(repositoryFullDirectoryPath)) { throw new DirectoryNotFoundException($"Failed to find repositoryDirectoryPath: {repositoryFullDirectoryPath}"); } context.UseRepository( repositoryDirectoryPath, repository => repository.Network.Push( repository.Branches, new PushOptions { CredentialsProvider = (url, usernameFromUrl, types) => new UsernamePasswordCredentials { Username = username, Password = password } } ) ); }
public FakeCakeContext () { testsDir = new DirectoryPath ( System.IO.Path.GetDirectoryName (System.Reflection.Assembly.GetExecutingAssembly ().Location)); var fileSystem = new FileSystem (); var environment = new CakeEnvironment (); var globber = new Globber (fileSystem, environment); log = new FakeLog (); var args = new FakeCakeArguments (); var processRunner = new ProcessRunner (environment, log); var registry = new WindowsRegistry (); var toolRepo = new ToolRepository (environment); var config = new Core.Configuration.CakeConfigurationProvider (fileSystem, environment).CreateConfiguration (new Dictionary<string, string> ()); var toolResStrat = new ToolResolutionStrategy (fileSystem, environment, globber, config); var toolLocator = new ToolLocator (environment, toolRepo, toolResStrat); context = new CakeContext (fileSystem, environment, globber, log, args, processRunner, registry, toolLocator); context.Environment.WorkingDirectory = testsDir; }
public void Restore(FilePath project, PackageLocation packageLocation, string verbosity = null) { string packageId; VersionRange versionRange; string targetFramework; DirectoryPath assetJsonOutput; try { // The mock installer wrote a mock project file containing id;version;framework;stageDirectory var contents = _fileSystem.File.ReadAllText(project.Value); var tokens = contents.Split(';'); if (tokens.Length != 4) { throw new ToolPackageException(LocalizableStrings.ToolInstallationRestoreFailed); } packageId = tokens[0]; versionRange = VersionRange.Parse(tokens[1]); targetFramework = tokens[2]; assetJsonOutput = new DirectoryPath(tokens[3]); } catch (IOException) { throw new ToolPackageException(LocalizableStrings.ToolInstallationRestoreFailed); } if (string.IsNullOrEmpty(packageId)) { throw new ToolPackageException(LocalizableStrings.ToolInstallationRestoreFailed); } var feedPackage = GetPackage( packageId, versionRange, packageLocation.NugetConfig, packageLocation.RootConfigDirectory); var packageVersion = feedPackage.Version; targetFramework = string.IsNullOrEmpty(targetFramework) ? "targetFramework" : targetFramework; var fakeExecutableSubDirectory = Path.Combine( packageId.ToLowerInvariant(), packageVersion.ToLowerInvariant(), "tools", targetFramework, Constants.AnyRid); var fakeExecutablePath = Path.Combine(fakeExecutableSubDirectory, FakeEntrypointName); _fileSystem.Directory.CreateDirectory(Path.Combine(assetJsonOutput.Value, fakeExecutableSubDirectory)); _fileSystem.File.CreateEmptyFile(Path.Combine(assetJsonOutput.Value, fakeExecutablePath)); _fileSystem.File.WriteAllText( assetJsonOutput.WithFile("project.assets.json").Value, fakeExecutablePath); _fileSystem.File.WriteAllText( assetJsonOutput.WithFile(FakeCommandSettingsFileName).Value, JsonSerializer.Serialize(new { Name = feedPackage.ToolCommandName })); }
public static Task <List <GlobalJsonBackwards> > GetExistingFilesBackwardsAsync(DirectoryPath directoryPath = default) => GetFilesBackwardsAsync(directoryPath ?? DirectoryPath.OS.Current, true);
/// <summary> /// Uncompress the specified archive. /// </summary> /// <param name="filePath">Archive to uncompress.</param> /// <param name="outputPath">Output path to uncompress into.</param> public abstract void Uncompress(FilePath filePath, DirectoryPath outputPath);
public Task<bool> Save<T>(T config, DirectoryPath dirPath = null) { return Save(config, config.GetType(), dirPath); }
protected override IReadOnlyCollection <IFile> GetAddinAssemblies(DirectoryPath path) { throw new NotSupportedException("Only tools can be resolved with this resolver."); }
private void OnSelectedFolderPathChanged() { App.Logger.TraceExt("NotesViewHierachical", "OnSelectedFolderPathChanged", Tuple.Create("SelectedFolderPath", SelectedFolderPath?.Formatted)); if (SelectedFolderPath == null) { return; } if (DisplayItems == null) { return; } var f = DisplayItems.Find(SelectedFolderPath, true); if (f != null) { if (!f.IsSelected) { App.Logger.TraceExt("NotesViewHierachical", "OnSelectedFolderPathChanged (1)", Tuple.Create("f.IsSelected", "true")); f.IsSelected = true; } } else { if (AllNotes == null && !SelectedFolderPath.IsRoot() && !SelectedFolderPath.EqualsIgnoreCase(SelectedFolder?.GetInternalPath())) { App.Logger.TraceExt("NotesViewHierachical", "OnSelectedFolderPathChanged (2)", Tuple.Create("SelectedFolder", SelectedFolder?.Header)); _initFolderPath = SelectedFolderPath; SelectedFolderPath = SelectedFolder?.GetInternalPath() ?? DirectoryPath.Root(); } else { if (DisplayItems.AllNotesViewWrapper != null) { if (!DisplayItems.AllNotesViewWrapper.IsSelected) { App.Logger.TraceExt("NotesViewHierachical", "OnSelectedFolderPathChanged (3)", Tuple.Create("DisplayItems.AllNotesWrapper.IsSelected", "true")); DisplayItems.AllNotesViewWrapper.IsSelected = true; } } else { var fod = DisplayItems.SubFolder.FirstOrDefault(p => !p.IsSpecialNode); if (fod != null && !fod.IsSelected) { App.Logger.TraceExt("NotesViewHierachical", "OnSelectedFolderPathChanged (4)", Tuple.Create("DisplayItems.SubFolder.FirstOrDefault().IsSelected", "true")); fod.IsSelected = true; } } } } }
private void ResyncDisplayItems(IList <INote> notes) { App.Logger.Trace("NotesViewHierachical", "ResyncDisplayItems", string.Join("\n", notes.Select(n => $"{n.UniqueName} {n.Title}"))); HierachicalWrapper_Folder root = new HierachicalWrapper_Folder("ROOT", this, DirectoryPath.Root(), true, false); if (Settings?.FolderViewShowRootNode == true) { var root2 = root.GetOrCreateRootFolder(); foreach (var note in notes) { var parent = root2; foreach (var pathcomp in note.Path.Enumerate()) { parent = parent.GetOrCreateFolder(pathcomp, out _); } parent.Add(note); } } else { foreach (var note in notes) { var parent = root; foreach (var pathcomp in note.Path.Enumerate()) { parent = parent.GetOrCreateFolder(pathcomp, out _); } parent.Add(note); } } DisplayItems.CopyPermanentsTo(root); root.Sort(); root.FinalizeCollection(Settings?.DeepFolderView ?? false); DisplayItems.Sync(root, new HierachicalWrapper_Folder[0]); }
public static void CopyFiles(ICakeContext context, IEnumerable <FilePath> filePaths, DirectoryPath targetDirectoryPath) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (filePaths == null) { throw new ArgumentNullException(nameof(filePaths)); } if (targetDirectoryPath == null) { throw new ArgumentNullException(nameof(targetDirectoryPath)); } var absoluteTargetDirectoryPath = targetDirectoryPath.MakeAbsolute(context.Environment); // Make sure the target directory exist. if (!context.FileSystem.Exist(absoluteTargetDirectoryPath)) { const string format = "The directory '{0}' do not exist."; var message = string.Format(CultureInfo.InvariantCulture, format, absoluteTargetDirectoryPath.FullPath); throw new DirectoryNotFoundException(message); } // Iterate all files and copy them. foreach (var filePath in filePaths) { CopyFileCore(context, filePath, absoluteTargetDirectoryPath.GetFilePath(filePath)); } }
public PackagePathResolver(DirectoryPath root) { _root = root; }
public static void CopyFileToDirectory(ICakeContext context, FilePath filePath, DirectoryPath targetDirectoryPath) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (filePath == null) { throw new ArgumentNullException(nameof(filePath)); } if (targetDirectoryPath == null) { throw new ArgumentNullException(nameof(targetDirectoryPath)); } CopyFile(context, filePath, targetDirectoryPath.GetFilePath(filePath)); }
public override int Execute() { var global = _options.ValueOrDefault <bool>("global"); var toolPath = _options.SingleArgumentOrDefault("tool-path"); DirectoryPath?toolDirectoryPath = null; if (!string.IsNullOrWhiteSpace(toolPath)) { if (!Directory.Exists(toolPath)) { throw new GracefulException( string.Format( LocalizableStrings.InvalidToolPathOption, toolPath)); } toolDirectoryPath = new DirectoryPath(toolPath); } (IToolPackageStore toolPackageStore, IToolPackageStoreQuery toolPackageStoreQuery, IToolPackageUninstaller toolPackageUninstaller) = _createToolPackageStoresAndUninstaller(toolDirectoryPath); IShellShimRepository shellShimRepository = _createShellShimRepository(toolDirectoryPath); var packageId = new PackageId(_options.Arguments.Single()); IToolPackage package = null; try { package = toolPackageStoreQuery.EnumeratePackageVersions(packageId).SingleOrDefault(); if (package == null) { throw new GracefulException( messages: new[] { string.Format( LocalizableStrings.ToolNotInstalled, packageId), }, isUserError: false); } } catch (InvalidOperationException) { throw new GracefulException( messages: new[] { string.Format( LocalizableStrings.ToolHasMultipleVersionsInstalled, packageId), }, isUserError: false); } try { using (var scope = new TransactionScope( TransactionScopeOption.Required, TimeSpan.Zero)) { foreach (var command in package.Commands) { shellShimRepository.RemoveShim(command.Name); } toolPackageUninstaller.Uninstall(package.PackageDirectory); scope.Complete(); } _reporter.WriteLine( string.Format( LocalizableStrings.UninstallSucceeded, package.Id, package.Version.ToNormalizedString()).Green()); return(0); } catch (Exception ex) when(ToolUninstallCommandLowLevelErrorConverter.ShouldConvertToUserFacingError(ex)) { throw new GracefulException( messages: ToolUninstallCommandLowLevelErrorConverter.GetUserFacingMessages(ex, packageId), verboseMessages: new[] { ex.ToString() }, isUserError: false); } }
public FakeDirectory CreateDirectory(DirectoryPath path) { return(CreateDirectory(new FakeDirectory(this, path))); }
public static void GitPushRef( this ICakeContext context, DirectoryPath repositoryDirectoryPath, string username, string password, string remote, string pushRefSpec) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (repositoryDirectoryPath == null) { throw new ArgumentNullException(nameof(repositoryDirectoryPath)); } if (remote == null) { throw new ArgumentNullException(nameof(remote)); } if (string.IsNullOrWhiteSpace(remote)) { throw new ArgumentException("Remote cannot be empty", nameof(remote)); } if (pushRefSpec == null) { throw new ArgumentNullException(nameof(pushRefSpec)); } if (string.IsNullOrWhiteSpace(pushRefSpec)) { throw new ArgumentException("Pushrefspec cannot be empty", nameof(pushRefSpec)); } if (username == null) { throw new ArgumentNullException(nameof(username)); } if (password == null) { throw new ArgumentNullException(nameof(password)); } var options = new PushOptions { CredentialsProvider = (url, usernameFromUrl, types) => new UsernamePasswordCredentials { Username = username, Password = password } }; context.UseRepository( repositoryDirectoryPath, repository => repository.Network.Push(repository.Network.Remotes[remote], repository.Tags[pushRefSpec].CanonicalName, options) ); }
public IEnumerable <DirectoryPath> ListFolder() { if (Settings?.FolderViewShowRootNode == false) { return new [] { DirectoryPath.Root() } }
protected virtual FilePath GetConfigFilePath(DirectoryPath dirPath, Type confType) { return dirPath.CombineFile(confType.Name + ".json"); }
IControl CreateContent(Template template, IDialog <bool> dialog) { var projectLocation = UserSettings.Folder("MostRecentlyUsedFolder") .Convert(v => v.Or(Optional.Some(_fuse.ProjectsDir)), d => d) .AutoInvalidate(TimeSpan.FromMilliseconds(100)); var validatedLocation = projectLocation.Validate(v => v.NativePath, ValidateExistingDirectory); var projectName = Property.Create( Optional.Some(_shell.MakeUnique(projectLocation.Latest().First().Value / "App").Name)); var validatedName = projectName.Validate(v => v.ToString(), DirectoryName.Validate); var possibleProjectName = projectLocation.CombineLatest( projectName, (loc, pro) => { return(loc.SelectMany(l => pro.Select(n => l / n))); }) .Select( d => d.HasValue && Directory.Exists(d.Value.NativePath) ? Optional.Some("Project '" + d.Value.Name + "' already exists in " + d.Value.ContainingDirectory.NativePath) : Optional.None()); return (Layout.Dock() .Bottom(Layout.Dock() .Right( Buttons.DefaultButtonPrimary( text: "Create", cmd: Observable.CombineLatest( projectName, projectLocation, (name, location) => { var projectDirectory = location.SelectMany(l => name.Select(n => l / n)) .Where(d => !_shell.Exists(d)); return Command.Create( isEnabled: projectDirectory.HasValue, action: async() => { var spawnTemplate = new SpawnTemplate(_shell); var resultPath = spawnTemplate.CreateProject(name.Value.ToString(), template, location.Value); var projectPath = resultPath / new FileName(name.Value + ".unoproj"); await Application.OpenDocument(projectPath, showWindow: true); dialog.Close(true); }); }).Switch()) .WithWidth(104)) .Right(Buttons.DefaultButton(text: "Cancel", cmd: Command.Enabled(() => dialog.Close(false))) .WithWidth(104) .WithPadding(right: new Points(16))) .Fill()) .Fill( Layout.StackFromTop( Label.Create("Name:", color: Theme.DefaultText) .WithPadding(LabelThickness), ValidatedTextBox.Create(validatedName) .WithPadding(ControlPadding), Control.Empty .WithHeight(8), Label.Create("Location:", color: Theme.DefaultText) .WithPadding(LabelThickness), Layout.Dock() .Right( Buttons.DefaultButton(text: "Browse", cmd: Command.Enabled(async() => { var directory = await dialog.BrowseForDirectory(await projectLocation.FirstAsync().Or(DirectoryPath.GetCurrentDirectory())); if (directory.HasValue) { projectLocation.Write(directory.Value, save: true); } })) .WithWidth(80) .WithHeight(22) .CenterVertically() .WithPadding(LabelThickness) ) .Fill(ValidatedTextBox.Create(validatedLocation) .WithPadding(ControlPadding)), ErrorLabel.Create(possibleProjectName) .WithPadding(ControlPadding))) .WithPadding(ControlPadding) .WithPadding(ControlPadding) .WithBackground(Theme.PanelBackground)); }
public IEnumerable <IDebugState> GetDebugStates(string serverWebUri, DirectoryPath directory, FilePath path) { var list = new List <DebugState> { new DebugState { StateType = StateType.Before, ServerID = ServerID, ParentID = Guid.Empty, ID = Workflow1ID, DisplayName = "Workflow1", HasError = false, Name = "DsfActivity", ActivityType = ActivityType.Workflow, StartTime = _startDate, EndTime = _startDate.AddMinutes(1) }, new DebugState { StateType = StateType.All, ServerID = ServerID, ParentID = Workflow1ID, ID = Assign1ID, DisplayName = "Assign1", HasError = false, Name = "Assign", ActivityType = ActivityType.Step, StartTime = _startDate.AddMinutes(1), EndTime = _startDate.AddMinutes(2) }, new DebugState { StateType = StateType.Before, ServerID = ServerID, ParentID = Workflow1ID, ID = Workflow2ID, DisplayName = "Workflow2", HasError = false, Name = "DsfActivity", ActivityType = ActivityType.Step, StartTime = _startDate.AddMinutes(2), EndTime = _startDate.AddMinutes(3) }, new DebugState { StateType = StateType.All, ServerID = ServerID, ParentID = Workflow2ID, ID = Assign2ID, DisplayName = "Assign2", HasError = false, Name = "Assign", ActivityType = ActivityType.Step, StartTime = _startDate.AddMinutes(3), EndTime = _startDate.AddMinutes(4) }, new DebugState { StateType = StateType.After, ServerID = ServerID, ParentID = Workflow1ID, ID = Workflow2ID, DisplayName = "Workflow2", HasError = false, Name = "DsfActivity", ActivityType = ActivityType.Step, StartTime = _startDate.AddMinutes(4), EndTime = _startDate.AddMinutes(5) }, new DebugState { StateType = StateType.After, ServerID = ServerID, ParentID = Guid.Empty, ID = Workflow1ID, DisplayName = "Workflow1", HasError = false, Name = "DsfActivity", ActivityType = ActivityType.Workflow, StartTime = _startDate.AddMinutes(5), EndTime = _startDate.AddMinutes(6) }, new DebugState { StateType = StateType.All, ServerID = ServerID, ParentID = Guid.Empty, ID = Assign3ID, DisplayName = "Assign3", HasError = false, Name = "Assign", ActivityType = ActivityType.Step, StartTime = _startDate.AddMinutes(6), EndTime = _startDate.AddMinutes(7) } }; return(list); }
public static bool SvnVacuum(this ICakeContext context, DirectoryPath directory, SvnVacuumSettings settings) { var vacuum = new SvnVacuum(context.Environment, SvnClientFactoryMethod); return(vacuum.Vacuum(directory, settings)); }
public static void Zip(this ICakeContext context, DirectoryPath rootPath, FilePath outputPath) { var filePaths = context.GetFiles(string.Concat(rootPath, "/**/*")); Zip(context, rootPath, outputPath, filePaths); }
public static bool SvnVacuum(this ICakeContext context, DirectoryPath directory) { return(SvnVacuum(context, directory, new SvnVacuumSettings())); }
private static async Task <List <GlobalJsonBackwards> > GetFilesBackwardsAsync(DirectoryPath directoryPath, bool existingOnly = false) => (await(directoryPath ?? DirectoryPath.OS.Current).GetFilesBackwardsAsync(FileName, existingOnly).ConfigureAwait(false)) .Select(item => new GlobalJsonBackwards(item)).ToList();
private FilePath GetFromRegistry() { // Gets a list of the files we should check. var files = new List <FilePath>(); using (var root = _registry.LocalMachine.OpenKey("Software\\Microsoft\\Windows Kits\\Installed Roots")) { string kitsRoot = root?.GetValue("KitsRoot10") as string; if (!string.IsNullOrWhiteSpace(kitsRoot)) { var kitsPath = new DirectoryPath(kitsRoot); string[] versions = root.GetSubKeyNames(); foreach (string version in versions.OrderByDescending(x => x)) { var versionPath = kitsPath.Combine($"bin\\{version}"); files.Add(_environment.Platform.Is64Bit ? versionPath.CombineWithFilePath("x64\\signtool.exe") : versionPath.CombineWithFilePath("x86\\signtool.exe")); } } } using (var root = _registry.LocalMachine.OpenKey("Software\\Microsoft\\Windows Kits\\Installed Roots")) { if (root != null) { var windowsKits = new[] { "KitsRoot10", "KitsRoot81", "KitsRoot" }; foreach (var kit in windowsKits) { var kitsRoot = root.GetValue(kit) as string; if (!string.IsNullOrWhiteSpace(kitsRoot)) { var kitsPath = new DirectoryPath(kitsRoot); files.Add(_environment.Platform.Is64Bit ? kitsPath.CombineWithFilePath("bin\\x64\\signtool.exe") : kitsPath.CombineWithFilePath("bin\\x86\\signtool.exe")); } } } } using (var root = _registry.LocalMachine.OpenKey("Software\\Microsoft\\Microsoft SDKs\\Windows")) { if (root != null) { var keyName = root.GetSubKeyNames(); foreach (var key in keyName) { var sdkKey = root.OpenKey(key); var installationFolder = sdkKey?.GetValue("InstallationFolder") as string; if (!string.IsNullOrWhiteSpace(installationFolder)) { var installationPath = new DirectoryPath(installationFolder); files.Add(installationPath.CombineWithFilePath("bin\\signtool.exe")); } } } } // Return the first path that exists. return(files.FirstOrDefault(file => _fileSystem.Exist(file))); }
/// <summary> /// Create a archive of the specified files. /// </summary> /// <param name="rootPath">The root path.</param> /// <param name="outputPath">The output path.</param> /// <param name="filePaths">The file paths.</param> /// <param name="level">The compression level (1-9).</param> public abstract void Compress(DirectoryPath rootPath, FilePath outputPath, IEnumerable <FilePath> filePaths, int level);
/// <summary> /// Gets commits from the repository the specified path is a part of. /// </summary> /// <param name="repositoryPath">The repository path.</param> public GitCommits(DirectoryPath repositoryPath) : base(repositoryPath) { }
public ToolRestoreCommandTests() { _packageVersionA = NuGetVersion.Parse("1.0.4"); _packageVersionWithCommandNameCollisionWithA = NuGetVersion.Parse("1.0.9"); _packageVersionB = NuGetVersion.Parse("1.0.4"); _reporter = new BufferedReporter(); _fileSystem = new FileSystemMockBuilder().UseCurrentSystemTemporaryDirectory().Build(); _nugetGlobalPackagesFolder = new DirectoryPath(NuGetGlobalPackagesFolder.GetLocation()); _temporaryDirectory = _fileSystem.Directory.CreateTemporaryDirectory().DirectoryPath; _pathToPlacePackages = Path.Combine(_temporaryDirectory, "pathToPlacePackage"); ToolPackageStoreMock toolPackageStoreMock = new ToolPackageStoreMock(new DirectoryPath(_pathToPlacePackages), _fileSystem); _toolPackageStore = toolPackageStoreMock; _toolPackageInstallerMock = new ToolPackageInstallerMock( _fileSystem, _toolPackageStore, new ProjectRestorerMock( _fileSystem, _reporter, new[] { new MockFeed { Type = MockFeedType.ImplicitAdditionalFeed, Packages = new List <MockFeedPackage> { new MockFeedPackage { PackageId = _packageIdA.ToString(), Version = _packageVersionA.ToNormalizedString(), ToolCommandName = _toolCommandNameA.ToString() }, new MockFeedPackage { PackageId = _packageIdB.ToString(), Version = _packageVersionB.ToNormalizedString(), ToolCommandName = _toolCommandNameB.ToString() }, new MockFeedPackage { PackageId = _packageIdWithCommandNameCollisionWithA.ToString(), Version = _packageVersionWithCommandNameCollisionWithA.ToNormalizedString(), ToolCommandName = "A" } } } }), installCallback: () => _installCalledCount++); ParseResult result = Parser.Instance.Parse("dotnet tool restore"); _appliedCommand = result["dotnet"]["tool"]["restore"]; Cli.CommandLine.Parser parser = Parser.Instance; _parseResult = parser.ParseFrom("dotnet tool", new[] { "restore" }); _localToolsResolverCache = new LocalToolsResolverCache( _fileSystem, new DirectoryPath(Path.Combine(_temporaryDirectory, "cache")), 1); }
internal FakeDirectory(FakeFileSystemTree tree, DirectoryPath path) { _tree = tree; Path = path; Content = new FakeDirectoryContent(this, tree.Comparer); }
public FilePath?GetPath(DirectoryPath repositoryPath) { return(_fs.Directory.EnumerateFiles(repositoryPath.Path, "*.sln") .Select <string, FilePath?>(x => new FilePath(x)) .FirstOrDefault()); }
/// <inheritdoc /> public ConfigurationService(DirectoryPath dirPath) { _dirPath = dirPath; EnsureFolderExists(); }
/// <summary> /// Gets a <see cref="IDirectory" /> instance representing the specified path. /// </summary> /// <param name="path">The path.</param> /// <returns>A <see cref="IDirectory" /> instance representing the specified path.</returns> public IDirectory GetDirectory(DirectoryPath path) { return(new Directory(path)); }
public override int Execute() { ValidateArguments(); DirectoryPath?toolPath = null; if (_toolPath != null) { toolPath = new DirectoryPath(_toolPath); } VersionRange versionRange = null; if (!string.IsNullOrEmpty(_packageVersion) && !VersionRange.TryParse(_packageVersion, out versionRange)) { throw new GracefulException( string.Format( LocalizableStrings.InvalidNuGetVersionRange, _packageVersion)); } (IToolPackageStore toolPackageStore, IToolPackageStoreQuery toolPackageStoreQuery, IToolPackageInstaller toolPackageInstaller, IToolPackageUninstaller toolPackageUninstaller) = _createToolPackageStoreInstallerUninstaller(toolPath, _forwardRestoreArguments); IShellShimRepository shellShimRepository = _createShellShimRepository(toolPath); IToolPackage oldPackageNullable = GetOldPackage(toolPackageStoreQuery); using (var scope = new TransactionScope( TransactionScopeOption.Required, TimeSpan.Zero)) { if (oldPackageNullable != null) { RunWithHandlingUninstallError(() => { foreach (RestoredCommand command in oldPackageNullable.Commands) { shellShimRepository.RemoveShim(command.Name); } toolPackageUninstaller.Uninstall(oldPackageNullable.PackageDirectory); }); } RunWithHandlingInstallError(() => { IToolPackage newInstalledPackage = toolPackageInstaller.InstallPackage( new PackageLocation(nugetConfig: GetConfigFile(), additionalFeeds: _additionalFeeds), packageId: _packageId, targetFramework: _framework, versionRange: versionRange, verbosity: _verbosity); EnsureVersionIsHigher(oldPackageNullable, newInstalledPackage); foreach (RestoredCommand command in newInstalledPackage.Commands) { shellShimRepository.CreateShim(command.Executable, command.Name); } PrintSuccessMessage(oldPackageNullable, newInstalledPackage); }); scope.Complete(); } return(0); }