public SingleTestRunBase Load(FileInfoBase fileInfo) { var document = this.ReadResultsFile(fileInfo); var features = this.ToFeatures(document); return new SpecRunSingleResults(features); }
private XDocument ReadResultsFile(FileInfoBase testResultsFile) { XDocument document; using (var stream = testResultsFile.OpenRead()) { using (var streamReader = new System.IO.StreamReader(stream)) { string content = streamReader.ReadToEnd(); int begin = content.IndexOf("<!-- Pickles Begin", StringComparison.Ordinal); content = content.Substring(begin); content = content.Replace("<!-- Pickles Begin", string.Empty); int end = content.IndexOf("Pickles End -->", System.StringComparison.Ordinal); content = content.Substring(0, end); content = content.Replace("<", "<").Replace(">", ">"); var xmlReader = XmlReader.Create(new System.IO.StringReader(content)); document = XDocument.Load(xmlReader); } } return document; }
public SpecRunSingleResults(FileInfoBase fileInfo) { var resultsDocument = this.ReadResultsFile(fileInfo); this.specRunFeatures = resultsDocument.Descendants("feature").Select(Parser.SpecRun.Factory.ToSpecRunFeature).ToList(); }
public static string MakeRelativePath(DirectoryInfoBase fromPath, FileInfoBase toPath) { if (fromPath == null) throw new ArgumentNullException("fromPath"); if (toPath == null) throw new ArgumentNullException("toPath"); string root = fromPath.FullName; if (!(root.EndsWith("\\") || root.EndsWith("/"))) root += "\\"; root += "a.txt"; Uri fromUri = new Uri(root); Uri toUri = new Uri(toPath.FullName); if (fromUri.Scheme != toUri.Scheme) { return toPath.FullName; } // path can't be made relative. Uri relativeUri = fromUri.MakeRelativeUri(toUri); string relativePath = Uri.UnescapeDataString(relativeUri.ToString()); if (toUri.Scheme.ToUpperInvariant() == "FILE") { relativePath = relativePath.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar); } return relativePath; }
public void Setup() { this._testFeature = new Feature { Name = "Test" }; this._featureFileInfo = this.FileSystem.FileInfo.FromFileName(FileSystem.Path.Combine(ROOT_PATH, FEATURE_PATH)); this._featureDirectoryNode = new FeatureNode(this._featureFileInfo, RELATIVE_PATH, this._testFeature); this._featureWithMeta = new FeatureWithMetaInfo(this._featureDirectoryNode); }
public void Setup() { this.testFeature = new Feature { Name = "Test" }; this.featureFileInfo = this.FileSystem.FileInfo.FromFileName(FileSystem.Path.Combine(RootPath, FeaturePath)); this.featureDirectoryNode = new FeatureNode(this.featureFileInfo, RelativePath, this.testFeature); this.featureWithMeta = new JsonFeatureWithMetaInfo(this.featureDirectoryNode); }
public XDocument Load(FileInfoBase fileInfo) { XDocument document; using (var stream = fileInfo.OpenRead()) { document = this.Load(stream); } return document; }
public static void AddFile(this ZipArchive zipArchive, FileInfoBase file, string directoryNameInArchive) { string fileName = Path.Combine(directoryNameInArchive, file.Name); ZipArchiveEntry entry = zipArchive.CreateEntry(fileName, CompressionLevel.Fastest); using (Stream zipStream = entry.Open(), fileStream = file.OpenRead()) { fileStream.CopyTo(zipStream); } }
private void AddTestResultFileIfItExists(FileInfoBase fileInfoBase) { if (fileInfoBase.Exists) { this.testResultsFiles.Add(fileInfoBase); } else { Log.Error("A test result file could not be found, it will be skipped: {0}", fileInfoBase.FullName); } }
private void StreamFile(FileInfoBase file) { // Set varaibles. const int bufferReadSize = 1024 * 8; var fileSize = file.Length; long start = 0; long end = fileSize - 1; // Check if range specified. if(Request.Headers.AllKeys.Contains("Range")) { // Extract range details. var range = Request.Headers.Get("Range"); var rangeRegex = new Regex(@"^bytes=(\d+)-(\d*)", RegexOptions.IgnoreCase); var match = rangeRegex.Match(range); // Extract start. if(match.Groups.Count>1 && !string.IsNullOrEmpty(match.Groups[1].Value)) { long.TryParse(match.Groups[1].Value, out start); } // Extract end. if(match.Groups.Count>2 && !string.IsNullOrEmpty(match.Groups[2].Value)) { long.TryParse(match.Groups[2].Value, out end); } // Check if Offset is valid. if(start < 0 || start > end) { Response.StatusCode = 416; Response.StatusDescription = "Requested Range Not Satisfiable"; Response.End(); return; } } if(start != 0) { Response.StatusCode = 206; Response.StatusDescription = "Partial Content"; } // Set headers. Response.ContentType = file.Name.ResoveContentType(); Response.AddHeader("Accept-Ranges", "bytes"); Response.AddHeader("Content-Range", string.Format("bytes {0}-{1}/{2}", start, end, fileSize)); Response.AddHeader("Content-Length", (end + 1 - start).ToString()); // Transmit the file. Response.OutputStream.TransmitFile(file, start, (end + 1 - start)); Response.End(); }
public XDocument Load(FileInfoBase fileInfo) { XDocument document; using (var stream = fileInfo.OpenRead()) { XmlReader xmlReader = XmlReader.Create(stream); document = XDocument.Load(xmlReader); stream.Close(); } return document; }
public static ICsvWriter Create(FileInfoBase fileInfo) { var csvConfiguration = new CsvConfiguration { Delimiter = ";", HasHeaderRecord = true }; var streamWriter = new StreamWriter(fileInfo.OpenWrite(), Encoding.UTF8); return new CsvHelper.CsvWriter(streamWriter, csvConfiguration); }
private List<Feature> ReadResultsFile(FileInfoBase testResultsFile) { List<Feature> result; using (var stream = testResultsFile.OpenRead()) { using (var reader = new StreamReader(stream)) { result = JsonConvert.DeserializeObject<List<Feature>>(reader.ReadToEnd()); } } return result; }
static void ListFile(FileInfoBase file) { if (!file.Exists) { throw new FileNotFoundException(file.FullName + " does not exist."); } Console.WriteLine(); Console.WriteLine(" Directory of {0}", file.Directory.FullName.TrimEnd('\\')); Console.WriteLine(); Console.WriteLine(String.Format("{0} {1,17} {2}", ToDisplayString(file.LastWriteTime), file.Length.ToString("#,##0"), file.Name)); Console.WriteLine(String.Format("{0,16} File(s) {1,14} bytes", 1, file.Length.ToString("#,##0"))); }
public bool ExtractDetails(FileInfoBase showFile) { // Run AtomicParsley to get details. var details = new Dictionary<string, string>(); if(!AtomicParsley.AtomicParsley.ExtractDetails(showFile.FullName, out details)) { return false; } // Extract the details out of the output. if(!details.ContainsKey("tvsh") || !details.ContainsKey("tves")) { return false; } // Set default values. ShowName = details["tvsh"]; SeasonNumber = null; EpisodeNumber = Convert.ToInt32(details["tves"]); EpisodeName = null; AiredDate = null; Overview = null; TVNetwork = null; Artworks = null; // Set optional values. if(details.ContainsKey("tvsn")) { SeasonNumber = Convert.ToInt32(details["tvsn"]); } if(details.ContainsKey("@nam")) { EpisodeName = details["@nam"]; } if(details.ContainsKey("@day")) { AiredDate = DateTime.Parse(details["@day"]); } if(details.ContainsKey("@desc")) { Overview = details["desc"]; } if(details.ContainsKey("tvnn")) { TVNetwork = details["tvnn"]; } HasDetails = true; return true; }
public bool IsRelevant(FileInfoBase fileInfo) { if (fileInfo == null) { return false; } string extension = fileInfo.Extension.ToUpperInvariant(); if (this.validExtensions.Contains(extension)) { return true; } return false; }
/// <summary> /// Loads a file from the file name. /// </summary> /// <param name="fileInfo">The file info.</param> /// <returns>The file's content.</returns> protected string LoadFile(FileInfoBase fileInfo) { // Data validation if (null == fileInfo) throw new ArgumentNullException("fileInfo"); // Load the file content MemoryStream memoryStream = new MemoryStream(); using (StreamReader streamReader = new StreamReader(fileInfo.OpenRead())) using (var fileWriter = new StreamWriter(memoryStream)) { fileWriter.Write(streamReader.ReadToEnd()); } // Read the code snippet from the file return Encoding.UTF8.GetString(memoryStream.ToArray()); }
public WorkingTVShow(ITVShow tvShow, FileInfoBase file) { File = file; Definition = tvShow.Definition; TVShowName = tvShow.TVShowName; SeasonNumber = tvShow.SeasonNumber; EpisodeNumber = tvShow.EpisodeNumber; Name = tvShow.Name; Description = tvShow.Description; Genres = tvShow.Genres; Cast = tvShow.Cast; Directors = tvShow.Directors; Screenwriters = tvShow.Screenwriters; ReleaseDate = tvShow.ReleaseDate; Network = tvShow.Network; Artwork = tvShow.Artwork; }
public bool IsMarkdownFile(FileInfoBase file) { switch (file.Extension.ToLowerInvariant()) { case ".markdown": case ".mdown": case ".mkdn": case ".md": case ".mdwn": case ".mdtxt": case ".mdtext": case ".text": case ".txt": return true; } return false; }
private static Definition ExtractDefinition(FileInfoBase file) { var streams = new MediaStreamsExtractor(file).Extract(); var videoStream = streams.Where(stream => stream is MediaStreamsExtractor.IVideoStream).Select(stream => ((MediaStreamsExtractor.IVideoStream) stream).Height).OrderByDescending(h => h); if(!videoStream .Any()) { return Definition.Unknown; } var height = videoStream.First(); if(height >= 1080) { return Definition.HD1080; } else if(height >= 720) { return Definition.HD720; } return Definition.SD; }
public static IFileReader CreateFromFileName(FileInfoBase fileInfoBase) { if (IsCsvFile(fileInfoBase.FullName)) { var reader = new CsvHelper.CsvReader(new StreamReader(fileInfoBase.OpenRead()), new CsvConfiguration { HasHeaderRecord = true, Delimiter = ";" }); return new CsvReader(reader); } if (IsExcelFile(fileInfoBase.FullName)) { var excelReader = ExcelReaderFactory.CreateOpenXmlReader(fileInfoBase.Open(FileMode.Open, FileAccess.Read)); excelReader.IsFirstRowAsColumnNames = true; return new ExcelReader(excelReader); } throw new InvalidOperationException(); }
static Task CopyInternalAsync(IFileSystem srcFileSystem, FileInfoBase srcFileInfo, IFileSystem dstFileSystem, FileInfoBase dstFileInfo) { return TaskHelpers.RunSynchronously(() => { if (srcFileInfo.Exists && dstFileInfo.Exists && srcFileInfo.LastWriteTimeUtc == dstFileInfo.LastWriteTimeUtc) { lock (_semaphore) { Console.WriteLine(" File up-to-date from \"" + srcFileInfo.FullName + "\" to \"" + dstFileInfo.FullName + "\""); } } else { byte[] bytes = srcFileSystem.File.ReadAllBytes(srcFileInfo.FullName); if (dstFileSystem is FileSystem) { EnsureDirectory(Path.GetDirectoryName(dstFileInfo.FullName)); } dstFileSystem.File.WriteAllBytes(dstFileInfo.FullName, bytes); if (dstFileSystem is FileSystem) { dstFileInfo.LastWriteTimeUtc = srcFileInfo.LastWriteTimeUtc; } else if (srcFileSystem is FileSystem) { srcFileInfo.LastWriteTimeUtc = dstFileSystem.FileInfo.FromFileName(dstFileInfo.FullName).LastWriteTimeUtc; } lock (_semaphore) { Console.WriteLine("{0,12} bytes copied from \"" + srcFileInfo.FullName + "\" to \"" + dstFileInfo.FullName + "\"", bytes.Length.ToString("#,##0")); ++_totalFiles; _totalBytes += bytes.Length; } } }); }
public virtual void ProcessFile(ITaskContext context, FileInfoBase file, string currentVersion, string currentReleaseVersion, string currentTestVersion, string newVersion) { var rel = file.FullName.Replace(context.Data["WorkingDirectory"] as string, "").TrimStart('/', '\\'); // Read the whole file. context.Log.InfoFormat("Reading file {0}",file.FullName); var text = context.FileSystem.File.ReadAllText(file.FullName); // Return if the file contents don't contain the version number var mode = (context.Data["Mode"] as string).ToLower(); switch (mode) { case "release": if (!text.Contains(currentVersion) && !text.Contains(currentReleaseVersion)) return; break; case "test": if (!text.Contains(currentVersion) && !text.Contains(currentTestVersion)) return; break; } context.Log.InfoFormat("Replacing version number in file {0}",file.FullName); // Replace all occurrences of the oldVersion with the newVersion text = text.Replace(currentVersion, newVersion); switch (mode) { case "release": text = text.Replace(currentReleaseVersion, newVersion); break; case "test": text = text.Replace(currentTestVersion, newVersion); break; } context.Log.InfoFormat("Writing file {0}",file.FullName); // Write the new file to the file system. context.FileSystem.File.WriteAllText(file.FullName, text); }
public bool IsMarkdownFile(FileInfoBase file) { if (file.Name.EndsWith("csproj.FileListAbsolute.txt")) { return false; } switch (file.Extension.ToLowerInvariant()) { case ".markdown": case ".mdown": case ".mkdn": case ".md": case ".mdwn": case ".mdtxt": case ".mdtext": case ".text": case ".txt": return true; } return false; }
public virtual void ProcessFile(ITaskContext context, FileInfoBase file, string[] filesToIgnore, string currentVersion, string newVersion) { // Should we ignore this? if (filesToIgnore.Contains(file.Name)) return; if (file.Extension.ToLower() == ".exe" || file.Extension.ToLower() == "*.dll") return; var rel = file.FullName.Replace(context.Data["WorkingDirectory"] as string, "").TrimStart('/', '\\'); if (rel.StartsWith(".git") || file.FullName.Contains("packages")) return; if ((context.Data["Mode"] as string).ToLower() == "test") if (rel == "deploy\\currentversion.txt") return; // Read the whole file. context.Log.InfoFormat("Reading file {0}",file.FullName); var text = context.FileSystem.File.ReadAllText(file.FullName); // Return if the file contents don't contain the version number if (!text.Contains(currentVersion)) return; context.Log.InfoFormat("Replacing version number in file {0}",file.FullName); // Replace all occurrences of the oldVersion with the newVersion text = text.Replace(currentVersion, newVersion); context.Log.InfoFormat("Writing file {0}",file.FullName); // Write the new file to the file system. context.FileSystem.File.WriteAllText(file.FullName, text); }
public void AddTestResultFile(FileInfoBase fileInfoBase) { this.AddTestResultFileIfItExists(fileInfoBase); }
private static IFileSystem CreateFileSystem(string path, DirectoryInfoBase dir, FileInfoBase file) { var directoryFactory = new Mock<IDirectoryInfoFactory>(); directoryFactory.Setup(d => d.FromDirectoryName(path)) .Returns(dir); var fileInfoFactory = new Mock<IFileInfoFactory>(); fileInfoFactory.Setup(f => f.FromFileName(path)) .Returns(file); var pathBase = new Mock<PathBase>(); pathBase.Setup(p => p.GetFullPath(It.IsAny<string>())) .Returns<string>(s => s); var fileSystem = new Mock<IFileSystem>(); fileSystem.SetupGet(f => f.DirectoryInfo).Returns(directoryFactory.Object); fileSystem.SetupGet(f => f.FileInfo).Returns(fileInfoFactory.Object); fileSystem.SetupGet(f => f.Path).Returns(pathBase.Object); FileSystemHelpers.Instance = fileSystem.Object; return fileSystem.Object; }
protected override ITestResults ConstructSingleTestResult(FileInfoBase fileInfo) { // not needed since we use the other constructor throw new NotSupportedException(); }
public SingleTestRunBase Load(FileInfoBase fileInfo) { return new XUnit2SingleResults(this.xmlDeserializer.Load(fileInfo)); }
public static void AddFile(this ZipArchive zipArchive, FileInfoBase file, ITracer tracer, string directoryNameInArchive) { Stream fileStream = null; try { fileStream = file.OpenRead(); } catch (Exception ex) { // tolerate if file in use. // for simplicity, any exception. tracer.TraceError(String.Format("{0}, {1}", file.FullName, ex)); return; } try { string fileName = ForwardSlashCombine(directoryNameInArchive, file.Name); ZipArchiveEntry entry = zipArchive.CreateEntry(fileName, CompressionLevel.Fastest); entry.LastWriteTime = file.LastWriteTime; using (Stream zipStream = entry.Open()) { fileStream.CopyTo(zipStream); } } finally { fileStream.Dispose(); } }