public bool ExistsEncodingFile()
{
string tempFilePath = GetEncodingTempFilePath();
bool isExist = _fileSystem.FileExists(tempFilePath);
return(isExist);
}
///<summary>
/// Outputs the token replaced to a file
///</summary>
///<param name="destination">the destination path</param>
///<exception cref="IOException">Occurs if the file already exists</exception>
public void To(string destination)
{
if (_fileSystemWrapper.FileExists(destination))
{
throw new IOException("File already exists. Delete it first");
}
_fileSystemWrapper.WriteAllText(destination, Input);
}
public Option <LocalChromeDriverInfo> FindDriverInfo(string driverDirectory)
{
var driverDirectoryInfo = new DirectoryInfo(driverDirectory);
var driverExists = _fileSystemWrapper.FileExists(Constants.DriverFileName, driverDirectoryInfo);
if (driverExists)
{
return(Option.Some(new LocalChromeDriverInfo(driverDirectoryInfo, _shellCommandExecutor)));
}
return(Option.None <LocalChromeDriverInfo>());
}
public MsBuildPath LocateMostRecentMsBuildPath()
{
var searchPaths = new List <string>();
foreach (var location in MsBuildLocations)
{
searchPaths.Add(location);
if (Fs.FileExists(location))
{
return(new MsBuildPath(location, new List <string>(searchPaths)));
}
}
return(new MsBuildPath(MsBuildLocations.Last(), new List <string>(searchPaths)));
}
public int?[] GetOriginalFileLineExecutionCounts(int?[] generatedSourceLineExecutionCounts, int sourceLineCount, ReferencedFile referencedFile)
{
if (generatedSourceLineExecutionCounts == null)
{
throw new ArgumentNullException("generatedSourceLineExecutionCounts");
}
if (referencedFile == null)
{
throw new ArgumentNullException("referencedFile");
}
else if (string.IsNullOrWhiteSpace(referencedFile.SourceMapFilePath))
{
return(generatedSourceLineExecutionCounts);
}
else if (!fileSystem.FileExists(referencedFile.SourceMapFilePath))
{
throw new ArgumentException("mapFilePath", string.Format("Cannot find map file '{0}'", referencedFile.SourceMapFilePath));
}
var consumer = this.GetConsumer(fileSystem.GetText(referencedFile.SourceMapFilePath));
var accumulated = new List <int?>(new int?[sourceLineCount + 1]);
for (var i = 1; i < generatedSourceLineExecutionCounts.Length; i++)
{
int?generatedCount = generatedSourceLineExecutionCounts[i];
if (generatedCount == null)
{
continue;
}
var matches = consumer.OriginalPositionsFor(i);
if (matches.Any())
{
foreach (var match in matches)
{
if (match.File.ToLower() != fileSystem.GetFileName(referencedFile.Path.ToLower()))
{
continue;
}
accumulated[match.LineNumber] = (accumulated[match.LineNumber] ?? 0) + generatedCount.Value;
}
}
}
return(accumulated.ToArray());
}
public HandlerResponseMessage HandleCommandLineOptions(ICommandLineOptions commandLineOptions)
{
var configFileExists = fileSystem.FileExists(defaultConfigFilePath);
if (!configFileExists || commandLineOptions.Force)
{
CreateConfigFile();
reporter.Report($@"Created default config file at {defaultConfigFilePath}");
}
else
{
reporter.Report($"Default config file already exists at: {defaultConfigFilePath} use the '--init' option combined with the '--force' option to overwrite");
}
return(new HandlerResponseMessage(true, false));
}
public HandlerResponseMessage HandleCommandLineOptions(ICommandLineOptions commandLineOptions)
{
commandLineOptions.ConfigFile = commandLineOptions.ConfigFile.Trim();
if (!fileSystem.FileExists(commandLineOptions.ConfigFile))
{
reporter.Report($"Config file not found at: {commandLineOptions.ConfigFile} use the '--init' option to create if one does not exist or the '--force' option to overwrite");
}
if (!commandLineOptions.LintPath.Any())
{
reporter.Report(commandLineOptions.GetUsage());
return(new HandlerResponseMessage(true, false));
}
return(new HandlerResponseMessage(true, true));
}
public IList <string> GetAllFilesMatching(string filter)
{
Console.WriteLine(filter);
Debug.WriteLine(filter);
//a full file i.e. c:\temp\file1.txt
if ((filter.LastIndexOf("*") == -1) && (Path.HasExtension(filter)))
{
var list = new List <String>();
if (_fileSystemWrapper.FileExists(filter))
{
list.Add(filter);
}
return(list);
}
_parser.Parse(filter);
return(GetAllFilesMatching(_parser.Folder, _parser.SearchPattern, _parser.Recursive));
}
public string FindSourceMap(string sourceFilePath)
{
if (sourceFilePath == null)
{
throw new ArgumentNullException("sourceFilePath");
}
// Start with the filename convention of having .map suffixed
var mapPath = sourceFilePath + ".map";
if (fileSystemWrapper.FileExists(mapPath))
{
return(mapPath);
}
return(null);
}
/// <summary>
/// Finds a Chutzpah test settings file given a directory. Will recursively scan current direcotry
/// and all directories above until it finds the file
/// </summary>
/// <param name="currentDirectory">the directory to start searching from</param>
/// <returns>Eithe the found setting file path or null</returns>
public string FindTestSettingsFile(string currentDirectory)
{
string settingsFilePath = null;
while (!string.IsNullOrEmpty(currentDirectory))
{
settingsFilePath = Path.Combine(currentDirectory, Constants.SettingsFileName);
if (fileSystem.FileExists(settingsFilePath))
{
break;
}
else
{
settingsFilePath = null;
currentDirectory = Path.GetDirectoryName(currentDirectory);
}
}
return(settingsFilePath);
}
public CompilerCache(IFileSystemWrapper fileSystem, IBinarySerializer binarySerializer)
{
hasher = new Hasher();
compilerCache = new ConcurrentDictionary <string, Tuple <DateTime, string> >();
filesystem = fileSystem;
this.binarySerializer = binarySerializer;
if (string.IsNullOrEmpty(GlobalOptions.Instance.CompilerCacheFile))
{
filename = Path.Combine(filesystem.GetTemporaryFolder(Constants.ChutzpahCompilerCacheFolder),
Constants.ChutzpahCompilerCacheFileName);
}
else
{
filename = GlobalOptions.Instance.CompilerCacheFile;
}
if (fileSystem.FileExists(filename) && GlobalOptions.Instance.CompilerCacheFileMaxSizeBytes > 0)
{
using (var cacheStream = fileSystem.Open(filename, FileMode.Open, FileAccess.Read))
{
compilerCache = DeserializeObject(cacheStream);
}
}
}
public CompilerCache(IFileSystemWrapper fileSystem, IBinarySerializer binarySerializer)
{
hasher = new Hasher();
compilerCache = new ConcurrentDictionary<string, Tuple<DateTime, string>>();
filesystem = fileSystem;
this.binarySerializer = binarySerializer;
if (string.IsNullOrEmpty(GlobalOptions.Instance.CompilerCacheFile))
{
filename = Path.Combine(filesystem.GetTemporaryFolder(Constants.ChutzpahCompilerCacheFolder),
Constants.ChutzpahCompilerCacheFileName);
}
else
{
filename = GlobalOptions.Instance.CompilerCacheFile;
}
if (fileSystem.FileExists(filename) && GlobalOptions.Instance.CompilerCacheFileMaxSizeBytes > 0)
{
using (var cacheStream = fileSystem.Open(filename, FileMode.Open, FileAccess.Read))
{
compilerCache = DeserializeObject(cacheStream);
}
}
}
public void IsValidIfFileExists(bool fileExists)
{
_fileSystemWrapper.FileExists(Arg.Any <string>()).Returns(fileExists);
_dataStore.FileName = "a";
Assert.AreEqual(fileExists, _dataStore.FileNameIsValid);
}