protected override async Task <IEnumerable <IDocument> > ExecuteAsync(IDocument input, IExecutionContext context) { context.LogDebug($"Processing Sass for {input.ToSafeDisplayString()}"); FilePath inputPath = await _inputPath.GetValueAsync(input, context); if (inputPath?.IsAbsolute != true) { inputPath = context.FileSystem.GetInputFile(new FilePath(Path.GetRandomFileName())).Path; context.LogWarning($"No input path found for document {input.ToSafeDisplayString()}, using {inputPath.FileName.FullPath}"); } string content = await input.GetStringAsync(); // Sass conversion FileImporter importer = new FileImporter(context.FileSystem, _importPathFunc); ScssOptions options = new ScssOptions { OutputStyle = _outputStyle, GenerateSourceMap = _generateSourceMap, SourceComments = _includeSourceComments, InputFile = inputPath.FullPath, TryImport = importer.TryImport }; IEnumerable <string> includePaths = _includePaths .Where(x => x != null) .Select(x => x.IsAbsolute ? x.FullPath : context.FileSystem.GetContainingInputPath(x)?.Combine(x)?.FullPath) .Where(x => x != null); options.IncludePaths.AddRange(includePaths); ScssResult result = Scss.ConvertToCss(content, options); // Process the result DirectoryPath relativeDirectory = context.FileSystem.GetContainingInputPath(inputPath); FilePath relativePath = relativeDirectory?.GetRelativePath(inputPath) ?? inputPath.FileName; FilePath cssPath = relativePath.ChangeExtension("css"); IDocument cssDocument = input.Clone( cssPath, await context.GetContentProviderAsync(result.Css ?? string.Empty)); // Generate a source map if requested if (_generateSourceMap && result.SourceMap != null) { FilePath sourceMapPath = relativePath.ChangeExtension("map"); IDocument sourceMapDocument = input.Clone( sourceMapPath, await context.GetContentProviderAsync(result.SourceMap)); return(new[] { cssDocument, sourceMapDocument }); } return(cssDocument.Yield()); }
public bool Build(IProject project) { AssemblerOutput output; using (IAssembler assembler = _assemblerFactory.CreateAssembler()) { AssemblerHelper.SetupAssembler(assembler, _inputFile, _outputFile, project.ProjectDirectory, project.IncludeDirs); string outputString; switch (_stepType) { case BuildStepType.All: outputString = assembler.Assemble(AssemblyFlags.Normal | AssemblyFlags.SymbolTable | AssemblyFlags.List); output = new AssemblerOutput(outputString, !outputString.Contains("error") && !outputString.Contains("Couldn't")); project.BuildSystem.ProjectOutput = _outputFile; project.BuildSystem.ListOutput = _outputFile.ChangeExtension("lst"); project.BuildSystem.LabelOutput = _outputFile.ChangeExtension("lab"); break; case BuildStepType.Assemble: outputString = assembler.Assemble(AssemblyFlags.Normal); output = new AssemblerOutput(outputString, !outputString.Contains("error") && !outputString.Contains("Couldn't")); project.BuildSystem.ProjectOutput = _outputFile; break; case BuildStepType.Listing: outputString = assembler.Assemble(AssemblyFlags.Normal | AssemblyFlags.List); output = new AssemblerOutput(outputString, !outputString.Contains("error") && !outputString.Contains("Couldn't")); project.BuildSystem.ListOutput = _outputFile.ChangeExtension("lst"); break; case BuildStepType.SymbolTable: outputString = assembler.Assemble(AssemblyFlags.Normal | AssemblyFlags.SymbolTable); output = new AssemblerOutput(outputString, !outputString.Contains("error") && !outputString.Contains("Couldn't")); project.BuildSystem.LabelOutput = _outputFile.ChangeExtension("lab"); break; default: throw new InvalidOperationException("Unknown step type"); } } _outputText = output.OutputText; return(output.Succeeded); }
public void SimpleWrappers() { Assert.AreEqual(Path.Combine("test"), FilePath.Combine("test")); Assert.AreEqual(Path.Combine("test", "1"), FilePath.Combine("test", "1")); Assert.AreEqual(Path.Combine("test/", @"1\"), FilePath.Combine("test/", @"1\")); const string aFilePath = @"hello\there.txt"; const string aFileName = "hello"; Assert.AreEqual(Path.GetExtension(aFilePath), FilePath.Extension(aFilePath)); Assert.AreEqual(Path.GetExtension(aFileName), FilePath.Extension(aFileName)); Assert.AreEqual( Path.ChangeExtension(aFilePath, ".png"), FilePath.ChangeExtension(aFilePath, ".png")); Assert.AreEqual( Path.ChangeExtension(aFileName, ".txt"), FilePath.ChangeExtension(aFileName, ".txt")); Assert.AreEqual(Path.GetDirectoryName(aFilePath), FilePath.DirectoryName(aFilePath)); Assert.AreEqual(Path.GetDirectoryName(aFileName), FilePath.DirectoryName(aFileName)); Assert.AreEqual(Path.HasExtension(aFilePath), FilePath.HasExtension(aFilePath)); Assert.AreEqual(Path.HasExtension(aFileName), FilePath.HasExtension(aFileName)); }
/// <summary> /// Saves the solution file. /// </summary> /// <param name = "reporter">The progress reporter to use for logging.</param> public override void Save(IProgressReporter reporter) { reporter.ProgressVisible = true; for (int i = 0; i < Nodes.Count; i++) { reporter.Report("Saving {0}.", Nodes[i].Name); Nodes[i].Save(reporter); //progressReporter.ProgressPercentage = (int)(((double)Nodes.Count / (double)i) * 100); } reporter.Report("Writing solution file."); using (var writer = new StreamWriter(FilePath.FullPath)) { using (var solutionWriter = new SolutionWriter(writer)) { solutionWriter.WriteSolution(this); } } reporter.Report("Writing solution settings."); Settings.Save(FilePath.ChangeExtension(".litesettings").FullPath); reporter.Report("Finished saving solution."); reporter.ProgressVisible = false; HasUnsavedData = false; }
/// <summary> /// Restarts MonoDevelop /// </summary> /// <param name="reopenWorkspace"> true to reopen current workspace. </param> internal virtual void RestartIde(bool reopenWorkspace) { var reopen = reopenWorkspace && IdeApp.Workspace != null && IdeApp.Workspace.Items.Count > 0; FilePath path = Environment.GetCommandLineArgs()[0]; if (Platform.IsMac && path.Extension == ".exe") { path = path.ChangeExtension(null); } if (!File.Exists(path)) { throw new Exception(path + " not found"); } var proc = new Process(); var psi = new ProcessStartInfo(path) { CreateNoWindow = true, UseShellExecute = false, WorkingDirectory = Environment.CurrentDirectory, }; var recentWorkspace = reopen ? DesktopService.RecentFiles.GetProjects().FirstOrDefault()?.FileName : string.Empty; if (!string.IsNullOrEmpty(recentWorkspace)) { psi.Arguments = recentWorkspace; } proc.StartInfo = psi; proc.Start(); }
private IReadOnlyCollection <CakeScriptAlias> InspectAssembly(AssemblyDefinition assembly, FilePath path) { var result = new List <CakeScriptAlias>(); var documentation = _documentation.Load(path.ChangeExtension("xml")); foreach (var module in assembly.Modules) { foreach (var type in module.Types) { if (type.IsSpecialName) { continue; } if (type.Name == "<Module>") { continue; } if (type.Name.StartsWith("_")) { continue; } if (type.IsAnonymousType()) { continue; } InspectType(assembly, type, documentation, result); } } return(result); }
/// <summary> /// Generates a normalized link given a path and other conditions. /// </summary> /// <param name="path">The path to get a link for.</param> /// <param name="host">The host for the link (or <c>null</c> to omit the host).</param> /// <param name="root">The root path for the link (or <c>null</c> for no root path).</param> /// <param name="scheme">The scheme for the link (or <c>null</c> for "http").</param> /// <param name="hidePages">An array of page names to hide (or <c>null</c> to not hide any pages).</param> /// <param name="hideExtensions">An array of file extensions to hide (or <c>null</c> to not hide extensions or an empty array to hide all file extensions).</param> /// <returns>A generated link.</returns> public static string GetLink(NormalizedPath path, string host, DirectoryPath root, string scheme, string[] hidePages, string[] hideExtensions) { // Remove index pages and extensions if a file path FilePath filePath = path as FilePath; if (filePath != null) { if (hidePages != null && filePath.FullPath != "/" && hidePages.Where(x => x != null).Select(x => x.EndsWith(".") ? x : x + ".").Any(x => filePath.FileName.FullPath.StartsWith(x))) { path = filePath.Directory; } else if (hideExtensions != null && (hideExtensions.Length == 0 || hideExtensions.Where(x => x != null).Select(x => x.StartsWith(".") ? x : "." + x).Contains(filePath.Extension))) { path = filePath.ChangeExtension(null); } } // Collapse the link to a string string link = string.Empty; if (path != null) { link = path.FullPath; if (string.IsNullOrWhiteSpace(link) || link == ".") { link = "/"; } if (!link.StartsWith("/")) { link = "/" + link; } } // Collapse the root and combine string rootLink = root == null ? string.Empty : root.FullPath; if (rootLink.EndsWith("/")) { rootLink = rootLink.Substring(0, rootLink.Length - 1); } // Add the host and convert to URI for escaping UriBuilder builder = new UriBuilder { Path = rootLink + link, Scheme = scheme ?? "http" }; bool hasHost = false; if (!string.IsNullOrWhiteSpace(host)) { builder.Host = host; hasHost = true; } Uri uri = builder.Uri; return(hasHost ? uri.AbsoluteUri : uri.AbsolutePath); }
public static string GetLink(NormalizedPath path, string host, DirectoryPath root, bool useHttps, bool hideIndexPages, bool hideExtensions) { // Remove index pages and extensions if a file path FilePath filePath = path as FilePath; if (filePath != null) { if (hideIndexPages && filePath.FileName.FullPath.StartsWith("index.")) { path = filePath.Directory; } else if (hideExtensions) { path = filePath.ChangeExtension(null); } } // Collapse the link to a string string link = string.Empty; if (path != null) { link = path.FullPath; if (string.IsNullOrWhiteSpace(link) || link == ".") { link = "/"; } if (!link.StartsWith("/")) { link = "/" + link; } } // Collapse the root and combine string rootLink = root == null ? string.Empty : root.FullPath; if (rootLink.EndsWith("/")) { rootLink = rootLink.Substring(0, rootLink.Length - 1); } // Add the host and convert to URI for escaping UriBuilder builder = new UriBuilder { Path = rootLink + link, Scheme = useHttps ? "https" : "http" }; bool hasHost = false; if (!string.IsNullOrWhiteSpace(host)) { builder.Host = host; hasHost = true; } Uri uri = builder.Uri; return(hasHost ? uri.AbsoluteUri : uri.AbsolutePath); }
public string Serialize(PublishInfo info, IProjectFile projFile) { FilePath filePath = info.DestinationFilePath; string sourceFilePath = info.SourceFilePath; string des = filePath.ChangeExtension(".csb"); string res = Services.ProjectOperations.CurrentSelectedSolution.ItemDirectory; return(CSCocosHelp.ConvertToBinByFlat(des, sourceFilePath, res)); }
public static byte [] GetDebugSymbolsFromAssemblyPath(FilePath path) { try { // Prefer MDBs, then PDBs. Mono outputs Foo.dll.mdb, so change the extension to that. var mdbPath = path.ChangeExtension(".dll.mdb"); if (mdbPath.FileExists) { return(File.ReadAllBytes(mdbPath)); } // This is intentionally not using mdbPath, because MS .NET names the symbol files // Foo.pdb, compared to Mono's Foo.dll.mdb. var pdbPath = path.ChangeExtension(".pdb"); return(pdbPath.FileExists ? File.ReadAllBytes(pdbPath) : null); } catch (Exception e) { Log.Warning(TAG, $"Could not get debug symbols for assembly at {path}", e); return(null); } }
public string Serialize(PublishInfo info, IProjectFile projFile) { FilePath destinationFilePath = (FilePath)info.DestinationFilePath; string sourceFilePath = info.SourceFilePath; string des = (string)destinationFilePath.ChangeExtension(".csb"); string itemDirectory = (string)Services.ProjectOperations.CurrentSelectedSolution.ItemDirectory; return(CSCocosHelp.ConvertToBinProto(des, sourceFilePath, itemDirectory)); }
public void Can_Change_Extension_Of_Path(string input, string extension, string expected) { // Given var path = new FilePath(input); // When path = path.ChangeExtension(extension); // Then path.ToString().ShouldBe(expected); }
public void Can_Change_Extension_Of_Path() { // Given var path = new FilePath("temp/hello.txt"); // When path = path.ChangeExtension(".dat"); // Then Assert.Equal("temp/hello.dat", path.ToString()); }
protected IFile GetOutputFile(IDocument input, IExecutionContext context) { FilePath path = null; if (_useWriteMetadata) { string metadataKey = null; // WritePath path = input.FilePath(Keys.WritePath); if (path != null) { metadataKey = Keys.WritePath; } // WriteFileName DirectoryPath relativeFileDir = input.DirectoryPath(Keys.RelativeFileDir); FilePath writeFileName = input.FilePath(Keys.WriteFileName); if (path == null && relativeFileDir != null && writeFileName != null) { metadataKey = Keys.WriteFileName; path = relativeFileDir.CombineFile(writeFileName); } // WriteExtension FilePath relativeFilePath = input.FilePath(Keys.RelativeFilePath); string writeExtension = input.String(Keys.WriteExtension); if (path == null && relativeFilePath != null && !string.IsNullOrWhiteSpace(writeExtension)) { metadataKey = Keys.WriteExtension; path = relativeFilePath.ChangeExtension(writeExtension); } // Warn if needed if (metadataKey != null && _warnOnWriteMetadata) { Trace.Warning("An extension or delegate was specified for the WriteFiles module, but the metadata key {0} took precedence for the document with source {1}." + " Call UseWriteMetadata(false) to prevent the special write metadata keys from overriding WriteFiles constructor values.", metadataKey, input.SourceString()); } } // Func if (path == null) { path = _path.Invoke <FilePath>(input, context); } return(path != null?context.FileSystem.GetOutputFile(path) : null); }
private void addDirButton_Click(object sender, EventArgs e) { int count = buildSeqList.Items.Count; FilePath fileName = new FilePath(_project.ProjectName + ".asm"); IBuildStep stepToAdd = new InternalBuildStep(count, BuildStepType.Assemble, fileName, fileName.ChangeExtension("8xk")); _currentConfig.AddStep(stepToAdd); buildSeqList.Items.Insert(count, stepToAdd); _needsSave = true; }
public void Can_Change_Extension_Of_Windows_Path(string input, string extension, string expected) { // Given var path = new FilePath(input); // When path = path.ChangeExtension(extension); // Then Assert.Equal(expected, path.ToString()); }
public void ShouldChangeExtension(string extension, string expected) { // Given FilePath path = new FilePath("temp/hello.txt"); // When path = path.ChangeExtension(extension); // Then Assert.AreEqual(expected, path.ToString()); }
public void CanChangeExtensionOfPath() { // Given FilePath path = new FilePath("temp/hello.txt"); // When path = path.ChangeExtension(".dat"); // Then Assert.AreEqual("temp/hello.dat", path.ToString()); }
public FilePath GetValidFormatName (object obj, FilePath fileName) { if (slnFileFormat.CanWriteFile (obj, this)) return slnFileFormat.GetValidFormatName (obj, fileName, this); else { string ext = MSBuildProjectService.GetExtensionForItem ((SolutionEntityItem)obj); if (!string.IsNullOrEmpty (ext)) return fileName.ChangeExtension ("." + ext); else return fileName; } }
/// <summary> /// Writes the document content to disk with the specified extension with the same /// base file name and relative path as the input file. This requires metadata /// for <c>RelativeFilePath</c> to be set (which is done by default by the <see cref="ReadFiles"/> module). /// </summary> /// <param name="extension">The extension to use for writing the file.</param> public WriteFiles(string extension) { if (extension == null) { throw new ArgumentNullException(nameof(extension)); } _path = (x, y) => { FilePath fileRelative = x.FilePath(Keys.RelativeFilePath); return(fileRelative?.ChangeExtension(extension)); }; _warnOnWriteMetadata = true; }
/// <summary> /// Gets the output path of the input document. /// </summary> /// <param name="input">The input document.</param> /// <param name="context">The execution context.</param> /// <returns>The outout path.</returns> protected FilePath GetOutputPath(IDocument input, IExecutionContext context) { FilePath path = null; if (_useWriteMetadata) { string metadataKey = null; // WritePath path = input.FilePath(Keys.WritePath); if (path != null) { metadataKey = Keys.WritePath; } // WriteFileName DirectoryPath relativeFileDir = input.DirectoryPath(Keys.RelativeFileDir); FilePath writeFileName = input.FilePath(Keys.WriteFileName); if (path == null && relativeFileDir != null && writeFileName != null) { metadataKey = Keys.WriteFileName; path = relativeFileDir.CombineFile(writeFileName); } // WriteExtension FilePath relativeFilePath = input.FilePath(Keys.RelativeFilePath); string writeExtension = input.String(Keys.WriteExtension); if (path == null && relativeFilePath != null && !string.IsNullOrWhiteSpace(writeExtension)) { metadataKey = Keys.WriteExtension; path = relativeFilePath.ChangeExtension(writeExtension); } // Warn if needed if (metadataKey != null && _warnOnWriteMetadata) { Trace.Warning($"An extension or delegate was specified for the WriteFiles module, but the metadata key {metadataKey} took precedence for the document with source {input.SourceString()}" + $" resulting in an output path of {path}. Call UseWriteMetadata(false) to prevent the special write metadata keys from overriding WriteFiles constructor values."); } } // Fallback to the default behavior function return(path ?? _path.Invoke <FilePath>(input, context, "while getting path")); }
static FilePath FilterFileName(SelectFileDialogData data, string fileName) { FilePath result = fileName; // FileDialog doesn't show the file extension when saving a file and chooses the extension based // the file filter. But * is no valid extension so the default file name extension needs to be set in that case. if (result.Extension == ".*") { var ext = Path.GetExtension(data.InitialFileName); if (!string.IsNullOrEmpty(ext)) { result = result.ChangeExtension(ext); } } return(result); }
public FilePath GetValidFormatName(object obj, FilePath fileName) { if (slnFileFormat.CanWriteFile(obj, this)) { return(slnFileFormat.GetValidFormatName(obj, fileName, this)); } else { string ext = MSBuildProjectService.GetExtensionForItem((SolutionEntityItem)obj); if (!string.IsNullOrEmpty(ext)) { return(fileName.ChangeExtension("." + ext)); } else { return(fileName); } } }
public Option <string> BuildSolution(FilePath SolutionPath) { var manager = MSEX.BuildManager.DefaultBuildManager; var project = new MSEX.ProjectInstance(SolutionPath); var logPath = SolutionPath.ChangeExtension("binlog"); var buildRequest = new MSEX.BuildRequestData(project, array("Build")); var result = manager.Build ( new MSEX.BuildParameters { Loggers = metacore.roitems <ILogger>(new MSL.ConsoleLogger()) }, buildRequest ); var targetResults = result.ResultsByTarget["Build"]; return(targetResults.ResultCode.ToString()); }
public void PropertyTest() { var filePath = new FilePath(DirectoryPath.OS.Temp, "Test.txt"); Assert.True(filePath.SplitValues.Count > 0); Assert.Equal("Test.txt", filePath.SplitValuesLast); Assert.Equal("Test.txt", filePath.FileName); Assert.Equal("Test", filePath.FileNameWithoutExtension); Assert.Equal(".txt", filePath.Extension); Assert.Equal(DirectoryPath.OS.Temp.IfEndsWithPathThenRemove(), filePath.DirectoryName); filePath.ChangeFileName("Hallo.xxx"); Assert.Equal("Hallo.xxx", filePath.FileName); Assert.Equal("Hallo", filePath.FileNameWithoutExtension); Assert.Equal(".xxx", filePath.Extension); Assert.Equal(DirectoryPath.OS.Temp.IfEndsWithPathThenRemove(), filePath.DirectoryName); filePath.ChangeExtension(".json"); Assert.Equal("Hallo.json", filePath.FileName); Assert.Equal("Hallo", filePath.FileNameWithoutExtension); Assert.Equal(".json", filePath.Extension); Assert.Equal(DirectoryPath.OS.Temp.IfEndsWithPathThenRemove(), filePath.DirectoryName); filePath.ChangeFileNameWithoutExtension("Test"); Assert.Equal("Test.json", filePath.FileName); Assert.Equal("Test", filePath.FileNameWithoutExtension); Assert.Equal(".json", filePath.Extension); Assert.Equal(DirectoryPath.OS.Temp.IfEndsWithPathThenRemove(), filePath.DirectoryName); filePath.RemoveExtension(); Assert.Equal("Test", filePath.FileName); Assert.Equal("Test", filePath.FileNameWithoutExtension); Assert.Equal("", filePath.Extension); Assert.Equal(DirectoryPath.OS.Temp.IfEndsWithPathThenRemove(), filePath.DirectoryName); }
public FilePath GetValidFormatName(object obj, FilePath fileName) { return(fileName.ChangeExtension(visualDExt)); }
public FilePath GetFileName(FilePath fileNameWithoutExtension) { return(fileNameWithoutExtension.ChangeExtension(".d")); }
public FilePath GetValidFormatName(object obj, FilePath fileName) { return(fileName.ChangeExtension(".md-nunit")); }
/// <inheritdoc /> public IEnumerable <IDocument> Execute(IReadOnlyList <IDocument> inputs, IExecutionContext context) { return(inputs .AsParallel() .SelectMany(context, input => { Trace.Verbose($"Processing Sass for {input.SourceString()}"); FilePath inputPath = _inputPath.Invoke <FilePath>(input, context); if (inputPath?.IsAbsolute != true) { inputPath = context.FileSystem.GetInputFile(new FilePath(Path.GetRandomFileName())).Path; Trace.Warning($"No input path found for document {input.SourceString()}, using {inputPath.FileName.FullPath}"); } string content = input.Content; // Sass conversion FileImporter importer = new FileImporter(context.FileSystem, _importPathFunc); ScssOptions options = new ScssOptions { OutputStyle = _outputStyle, GenerateSourceMap = _generateSourceMap, SourceComments = _includeSourceComments, InputFile = inputPath.FullPath, TryImport = importer.TryImport }; options.IncludePaths.AddRange( _includePaths .Where(x => x != null) .Select(x => x.IsAbsolute ? x.FullPath : context.FileSystem.GetContainingInputPath(x)?.Combine(x)?.FullPath) .Where(x => x != null)); ScssResult result = Scss.ConvertToCss(content, options); // Process the result DirectoryPath relativeDirectory = context.FileSystem.GetContainingInputPath(inputPath); FilePath relativePath = relativeDirectory?.GetRelativePath(inputPath) ?? inputPath.FileName; FilePath cssPath = relativePath.ChangeExtension("css"); IDocument cssDocument = context.GetDocument( input, context.GetContentStream(result.Css ?? string.Empty), new MetadataItems { { Keys.RelativeFilePath, cssPath }, { Keys.WritePath, cssPath } }); IDocument sourceMapDocument = null; if (_generateSourceMap && result.SourceMap != null) { FilePath sourceMapPath = relativePath.ChangeExtension("map"); sourceMapDocument = context.GetDocument( input, context.GetContentStream(result.SourceMap), new MetadataItems { { Keys.RelativeFilePath, sourceMapPath }, { Keys.WritePath, sourceMapPath } }); } return new[] { cssDocument, sourceMapDocument }; }) .Where(x => x != null)); }
public FilePath GetValidFormatName (object obj, FilePath fileName) { return fileName.ChangeExtension (visualDExt); }
public FilePath GetFileName(FilePath fileNameWithoutExtension) { return fileNameWithoutExtension.ChangeExtension(".d"); }
/// <summary> /// Constructs a unique filename using the extension of the current file /// </summary> /// <returns></returns> public static FilePath UniqueName(this FilePath path) { var ext = $"{guid().ToString("N")}.{path.Extension}"; return(path.ChangeExtension(ext)); }
public FilePath GetValidFormatName (object obj, FilePath fileName) { return fileName.ChangeExtension (".md-nunit"); }