public override void CreateDirectory (FilePath path)
{
Repository repo = GetRepository (path);
repo.ClearCachedVersionInfo (path);
System.IO.Directory.CreateDirectory (path);
repo.Add (path, false, new ProgressMonitor ());
}
public virtual string GetDirectoryDotSvn (FilePath path)
{
if (Directory.Exists (path.Combine (".svn")))
return path;
return String.Empty;
}
public override void Setup ()
{
svnRoot = new FilePath (FileService.CreateTempDirectory ());
repoLocation = "file://" + svnRoot + "/repo";
backend = new UnixSvnBackend ();
base.Setup ();
}
WorkspaceObjectReader GetObjectReaderForFile (FilePath file, Type type)
{
foreach (var r in GetObjectReaders ())
if (r.CanRead (file, type))
return r;
return null;
}
public override void Setup ()
{
// Generate directories and a svn util.
rootUrl = new FilePath (FileService.CreateTempDirectory () + Path.DirectorySeparatorChar);
rootCheckout = new FilePath (FileService.CreateTempDirectory () + Path.DirectorySeparatorChar);
Directory.CreateDirectory (rootUrl.FullPath + "repo.git");
repoLocation = "file:///" + rootUrl.FullPath + "repo.git";
// Initialize the bare repo.
InitCommand ci = new InitCommand ();
ci.SetDirectory (new Sharpen.FilePath (rootUrl.FullPath + "repo.git"));
ci.SetBare (true);
ci.Call ();
FileRepository bare = new FileRepository (new Sharpen.FilePath (rootUrl.FullPath + "repo.git"));
string branch = Constants.R_HEADS + "master";
RefUpdate head = bare.UpdateRef (Constants.HEAD);
head.DisableRefLog ();
head.Link (branch);
// Check out the repository.
Checkout (rootCheckout, repoLocation);
repo = GetRepo (rootCheckout, repoLocation);
DOT_DIR = ".git";
}
public MSBuildProject(FilePath filePath)
{
FilePath = filePath;
_msBuildProject = ProjectRootElement.Open(filePath.FullPath, _globalCollection);
foreach (var item in _msBuildProject.Items)
{
if (item.ItemType == "Reference")
References.Add(item.Include);
else if (item.ItemType == "Compile" || item.ItemType == "None")
{
var entry = new ProjectFileEntry(new FilePath(this.ProjectDirectory, item.Include));
foreach (var element in item.Metadata)
{
if (element.Name == "DependentUpon")
{
entry.Dependencies.Add(element.Value);
}
}
entry.ParentProject = this;
AddFileEventHandlers(entry);
ProjectFiles.Add(entry);
}
}
SetupEventHandlers();
HasUnsavedData = false;
}
bool RunDialog (OpenFileDialogData data)
{
Application.EnableVisualStyles ();
FileDialog fileDlg = null;
if (data.Action == Gtk.FileChooserAction.Open)
fileDlg = new OpenFileDialog ();
else
fileDlg = new SaveFileDialog ();
var dlg = new CustomOpenFileDialog (fileDlg, data);
SelectFileDialogHandler.SetCommonFormProperties (data, dlg.FileDialog);
using (dlg) {
rootForm = new WinFormsRoot ();
if (dlg.ShowDialog (rootForm) == DialogResult.Cancel) {
return false;
}
FilePath[] paths = new FilePath [fileDlg.FileNames.Length];
for (int n = 0; n < fileDlg.FileNames.Length; n++)
paths [n] = fileDlg.FileNames [n];
data.SelectedFiles = paths;
if (dlg.SelectedEncodingId != null)
data.Encoding = dlg.SelectedEncodingId > 0 ? Encoding.GetEncoding (dlg.SelectedEncodingId) : null;
if (dlg.SelectedViewer != null)
data.SelectedViewer = dlg.SelectedViewer;
data.CloseCurrentWorkspace = dlg.CloseCurrentWorkspace;
}
return true;
}
public bool Exists(FilePath filePath)
{
var path = filePath.Path;
return filePath.IsDirectory
? Directory.Exists(path)
: File.Exists(path);
}
public static IAsyncOperation Package (MonoMacProject project, ConfigurationSelector configSel,
MonoMacPackagingSettings settings, FilePath target)
{
IProgressMonitor mon = IdeApp.Workbench.ProgressMonitors.GetOutputProgressMonitor (
GettextCatalog.GetString ("Packaging Output"),
MonoDevelop.Ide.Gui.Stock.RunProgramIcon, true, true);
var t = new System.Threading.Thread (() => {
try {
using (mon) {
BuildPackage (mon, project, configSel, settings, target);
}
} catch (Exception ex) {
mon.ReportError ("Unhandled error in packaging", null);
LoggingService.LogError ("Unhandled exception in packaging", ex);
} finally {
mon.Dispose ();
}
}) {
IsBackground = true,
Name = "Mac Packaging",
};
t.Start ();
return mon.AsyncOperation;
}
public static BuildResult CompileXibFiles (IProgressMonitor monitor, IEnumerable<ProjectFile> files,
FilePath outputRoot)
{
var result = new BuildResult ();
var ibfiles = GetIBFilePairs (files, outputRoot).Where (NeedsBuilding).ToList ();
if (ibfiles.Count > 0) {
monitor.BeginTask (GettextCatalog.GetString ("Compiling interface definitions"), 0);
foreach (var file in ibfiles) {
file.EnsureOutputDirectory ();
var args = new ProcessArgumentBuilder ();
args.AddQuoted (file.Input);
args.Add ("--compile");
args.AddQuoted (file.Output);
var psi = new ProcessStartInfo ("ibtool", args.ToString ());
monitor.Log.WriteLine (psi.FileName + " " + psi.Arguments);
psi.WorkingDirectory = outputRoot;
string errorOutput;
int code;
try {
code = ExecuteCommand (monitor, psi, out errorOutput);
} catch (System.ComponentModel.Win32Exception ex) {
LoggingService.LogError ("Error running ibtool", ex);
result.AddError (null, 0, 0, null, "ibtool not found. Please ensure the Apple SDK is installed.");
return result;
}
if (code != 0) {
//FIXME: parse the plist that ibtool returns
result.AddError (null, 0, 0, null, "ibtool returned error code " + code);
}
}
monitor.EndTask ();
}
return result;
}
FileSystemExtension GetNextForPath (FilePath file, bool isDirectory)
{
FileSystemExtension nx = next;
while (nx != null && !nx.CanHandlePath (file, isDirectory))
nx = nx.next;
return nx;
}
/// <summary>
/// Retrieve and display annotations for a given VersionControlItem
/// </summary>
/// <param name="repo">
/// A <see cref="Repository"/> to which file belongs
/// </param>
/// <param name="file">
/// A <see cref="FilePath"/>: The file to annotate
/// </param>
/// <param name="test">
/// A <see cref="System.Boolean"/>: Whether this is a test run
/// </param>
/// <returns>
/// A <see cref="System.Boolean"/>: Whether annotations are supported
/// </returns>
public static bool Show (Repository repo, FilePath file, bool test)
{
if (test){
if (null != repo && repo.CanGetAnnotations (file)) {
foreach (Ide.Gui.Document guidoc in IdeApp.Workbench.Documents) {
if (guidoc.FileName.Equals (file)) {
SourceEditorView seview = guidoc.ActiveView as SourceEditorView;
if (null != seview &&
seview.TextEditor.HasMargin (typeof (AnnotationMargin)) &&
seview.TextEditor.GetMargin (typeof (AnnotationMargin)).IsVisible) {
return false;
}
}
}
return true;
}
return false;
}
MonoDevelop.Ide.Gui.Document doc = IdeApp.Workbench.OpenDocument (file, true);
SourceEditorView view = doc.ActiveView as SourceEditorView;
if (view != null) {
if (view.TextEditor.HasMargin (typeof (AnnotationMargin))) {
view.TextEditor.GetMargin (typeof (AnnotationMargin)).IsVisible = true;
} else {
view.TextEditor.InsertMargin (0, new AnnotationMargin (repo, view.TextEditor, doc));
}
view.TextEditor.QueueDraw ();
}
return true;
}
public override string GetPathUrl (FilePath path)
{
lock (client) {
Uri u = client.GetUriFromWorkingCopy (path);
return u != null ? u.ToString () : null;
}
}
public IncludeNewFilesDialog (string title, FilePath baseDirectory)
{
this.Build ();
this.Title = title;
this.baseDirectory = baseDirectory;
treeviewFiles.Model = store;
treeviewFiles.HeadersVisible = false; // Headers are untranslated because they're hidden as default
TreeViewColumn textColumn = new TreeViewColumn ();
CellRendererToggle toggleRender = new CellRendererToggle ();
toggleRender.Toggled += ToggleRenderToggled;
textColumn.PackStart (toggleRender, false);
textColumn.AddAttribute (toggleRender, "active", Columns.IsToggled);
textColumn.Title = "Name";
var pixbufRenderer = new CellRendererImage ();
textColumn.PackStart (pixbufRenderer, false);
textColumn.AddAttribute (pixbufRenderer, "image", Columns.IconOpened);
textColumn.AddAttribute (pixbufRenderer, "image-expander-open", Columns.IconOpened);
textColumn.AddAttribute (pixbufRenderer, "image-expander-closed", Columns.IconClosed);
CellRendererText textRenderer = new CellRendererText ();
textColumn.PackStart (textRenderer, false);
textColumn.AddAttribute (textRenderer, "text", Columns.Text);
treeviewFiles.AppendColumn (textColumn);
buttonExcludeAll.Clicked += ButtonExcludeAllClicked;
buttonIncludeAll.Clicked += ButtonIncludeAllClicked;
buttonOk.Clicked += ButtonOkClicked;
}
protected override void Run ()
{
var doc = IdeApp.Workbench.ActiveDocument;
var currentLocation = doc.Editor.Caret.Location;
var controller = doc.ParsedDocument.GetTopLevelTypeDefinition (currentLocation);
string controllerName = controller.Name;
int pos = controllerName.LastIndexOf ("Controller", StringComparison.Ordinal);
if (pos > 0)
controllerName = controllerName.Remove (pos);
var baseDirectory = doc.FileName.ParentDirectory.ParentDirectory;
string actionName = doc.ParsedDocument.GetMember (currentLocation).Name;
var viewFoldersPaths = new FilePath[] {
baseDirectory.Combine ("Views", controllerName),
baseDirectory.Combine ("Views", "Shared")
};
var viewExtensions = new string[] { ".aspx", ".cshtml" };
foreach (var folder in viewFoldersPaths) {
foreach (var ext in viewExtensions) {
var possibleFile = folder.Combine (actionName + ext);
if (File.Exists (possibleFile)) {
IdeApp.Workbench.OpenDocument (possibleFile);
return;
}
}
}
MessageService.ShowError ("Matching view cannot be found.");
}
public XcodeSyncBackContext (FilePath projectDir, Dictionary<string,DateTime> syncTimes,
NSObjectInfoService infoService, DotNetProject project)
: base (projectDir, syncTimes)
{
InfoService = infoService;
Project = project;
}
public override Repository GetRepositoryReference(FilePath path, string id)
{
if (!IsVersioned(path))
return null;
return new GitRepository(this, FindRepositoryPath(path));
}
public override IEnumerable<MemberReference> FindReferences (ProjectDom dom, FilePath fileName, IEnumerable<INode> searchedMembers)
{
HashSet<int > positions = new HashSet<int> ();
var editor = TextFileProvider.Instance.GetTextEditorData (fileName);
FindMemberAstVisitor visitor = new FindMemberAstVisitor (editor.Document);
visitor.IncludeXmlDocumentation = IncludeDocumentation;
visitor.Init (searchedMembers);
if (!visitor.FileContainsMemberName ()) {
yield break;
}
var doc = ProjectDomService.ParseFile (dom, fileName, () => editor.Text);
if (doc == null || doc.CompilationUnit == null)
yield break;
var resolver = new NRefactoryResolver (dom, doc.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, editor, fileName);
visitor.ParseFile (resolver);
visitor.RunVisitor (resolver);
foreach (var reference in visitor.FoundReferences) {
if (positions.Contains (reference.Position))
continue;
positions.Add (reference.Position);
yield return reference;
}
visitor.ClearParsers ();
}
public override void Setup ()
{
rootUrl = new FilePath (FileService.CreateTempDirectory ());
repoLocation = "svn://localhost:3690/repo";
svnServe = new Process ();
base.Setup ();
}
public bool ContainsFile (FilePath fileName)
{
for (int n=0; n<items.Count; n++)
if (items [n].LocalPath == fileName)
return true;
return false;
}
public RuleFactory(FilePath rootDirectory, IFileSystem files)
{
_rootDirectory = rootDirectory;
_files = files;
_modulesPath = new FilePath("_rules/Modules.rule");
}
public override Repository GetRepositoryReference (FilePath path, string id)
{
GitRepository repo;
if (!repositories.TryGetValue (path.CanonicalPath, out repo) || repo.Disposed)
repositories [path.CanonicalPath] = repo = new GitRepository (this, path, null);
return repo;
}
public bool Run(SelectFileDialogData data)
{
CommonDialog dlg = null;
if (data.Action == Gtk.FileChooserAction.Open)
dlg = new OpenFileDialog();
else if (data.Action == Gtk.FileChooserAction.Save)
dlg = new SaveFileDialog();
else if (data.Action == Gtk.FileChooserAction.SelectFolder)
dlg = new FolderBrowserDialog ();
if (dlg is FileDialog)
SetCommonFormProperties (data, dlg as FileDialog);
else
SetFolderBrowserProperties (data, dlg as FolderBrowserDialog);
using (dlg) {
WinFormsRoot root = new WinFormsRoot();
if (dlg.ShowDialog(root) == DialogResult.Cancel)
return false;
if (dlg is FileDialog) {
var fileDlg = dlg as OpenFileDialog;
FilePath[] paths = new FilePath [fileDlg.FileNames.Length];
for (int n=0; n < fileDlg.FileNames.Length; n++)
paths [n] = fileDlg.FileNames [n];
data.SelectedFiles = paths;
} else {
var folderDlg = dlg as FolderBrowserDialog;
data.SelectedFiles = new [] { new FilePath (folderDlg.SelectedPath) };
}
return true;
}
}
public override void Setup ()
{
RemotePath = new FilePath (FileService.CreateTempDirectory ());
RemoteUrl = "svn://localhost:3690/repo";
SvnServe = new Process ();
base.Setup ();
}
public bool Run(ConfigNode cfg)
{
fLastException = null;
Console.WriteLine("Starting CreateHDFFromASC...");
fWorkingDir = cfg["working.dir", AppDomain.CurrentDomain.BaseDirectory].AsFilePath();
try
{
if (cfg["from.asc.to.xyz", false].AsBool())
ConvertToXYZ(cfg);
if (cfg["from.xyz.to.mgd", false].AsBool())
ConvertToMGD(cfg);
if (cfg["from.mgd.to.hdf", false].AsBool())
ConvertToHDF(cfg);
if (cfg["glue.hdfs", false].AsBool())
GlueHDFs(cfg);
Console.WriteLine("CreateHDFFromASC finished successfully...");
return true;
}
catch (Exception ex)
{
fLastException = ex;
return false;
}
}
public override bool CanExecute(FilePath path)
{
UnixFileInfo fi = new UnixFileInfo (path);
if (!fi.Exists)
return false;
return 0 != (fi.FileAccessPermissions & (FileAccessPermissions.UserExecute | FileAccessPermissions.GroupExecute | FileAccessPermissions.OtherExecute));
}
void androidPackageTest (bool signed)
{
var projectFile = context.WorkingDirectory
.Combine ("TestProjects/HelloWorldAndroid/HelloWorldAndroid/")
.CombineWithFilePath ("HelloWorldAndroid.csproj");
projectFile = new FilePath ("./TestProjects/HelloWorldAndroid/HelloWorldAndroid/HelloWorldAndroid.csproj");
FilePath apkFile = null;
try {
apkFile = context.CakeContext.AndroidPackage(
projectFile,
signed,
c => {
c.Verbosity = Verbosity.Diagnostic;
c.Configuration = "Release";
});
} catch (Exception ex) {
Console.WriteLine(ex);
context.DumpLogs();
Assert.Fail(context.GetLogs());
}
Assert.IsNotNull (apkFile);
Assert.IsNotNull (apkFile.FullPath);
Assert.IsNotEmpty (apkFile.FullPath);
Assert.IsTrue (System.IO.File.Exists (apkFile.FullPath));
}
//TODO: handle errors
public AvdWatcher ()
{
VirtualDevices = new AndroidVirtualDevice[0];
FilePath home = Environment.GetFolderPath (Environment.SpecialFolder.Personal);
if (PropertyService.IsWindows) {
home = home.ParentDirectory;
}
avdDir = home.Combine (".android", "avd");
if (!Directory.Exists (avdDir))
Directory.CreateDirectory (avdDir);
var avds = Directory.GetFiles (avdDir, "*.ini");
UpdateAvds (avds, null);
//FSW on mac is unreliable
if (PropertyService.IsMac) {
modTimes = new Dictionary<string, DateTime> ();
foreach (var f in avds)
modTimes[f] = File.GetLastWriteTimeUtc (f);
timeoutId = GLib.Timeout.Add (750, HandleTimeout);
} else {
CreateFsw ();
}
}
public override IEnumerable<MemberReference> FindReferences (ProjectDom dom, FilePath fileName, IEnumerable<INode> searchedMembers)
{
var editor = TextFileProvider.Instance.GetTextEditorData (fileName);
AspNetAppProject project = dom.Project as AspNetAppProject;
if (project == null)
yield break;
var unit = AspNetParserService.GetCompileUnit (project, fileName, true);
if (unit == null)
yield break;
var refman = new DocumentReferenceManager (project);
var parsedAspDocument = (AspNetParsedDocument)new AspNetParser ().Parse (dom, fileName, editor.Text);
refman.Doc = parsedAspDocument;
var usings = refman.GetUsings ();
var documentInfo = new DocumentInfo (dom, unit, usings, refman.GetDoms ());
var builder = new AspLanguageBuilder ();
var buildDocument = new Mono.TextEditor.Document ();
var offsetInfos = new List<LocalDocumentInfo.OffsetInfo> ();
buildDocument.Text = builder.BuildDocumentString (documentInfo, editor, offsetInfos, true);
var parsedDocument = AspLanguageBuilder.Parse (dom, fileName, buildDocument.Text);
foreach (var member in searchedMembers) {
foreach (var reference in SearchMember (member, dom, fileName, editor, buildDocument, offsetInfos, parsedDocument)) {
yield return reference;
}
}
}
public bool ShouldOpenInXcode (FilePath fileName)
{
if (!HasInterfaceDefinitionExtension (fileName))
return false;
var file = dnp.Files.GetFile (fileName);
return file != null && (file.BuildAction == BuildAction.InterfaceDefinition);
}
public static void S3Upload(this ICakeContext context, FilePath filePath, string key, UploadSettings settings)
{
context.CreateManager().Upload(filePath, key, settings);
}
/// <summary>
/// Queries the related ini file and looks for Archive ordering information
/// </summary>
/// <param name="release">GameRelease to query for</param>
/// <param name="path">Path to the file containing INI data</param>
/// <returns>Any Archive ordering info retrieved from the ini definition</returns>
public static IEnumerable <FileName> GetIniListings(GameRelease release, FilePath path)
{
return(GetIniListings(release, FileSystem.File.OpenRead(path.Path)));
}
public static async Task <string> CompareCoverage(this ICakeContext context, FilePath upstream, FilePath current)
{
var fromCurrentTable = await ExtractTableFromHtml(current.FullPath);
var fromMasterTable = await ExtractTableFromHtml(upstream.FullPath);
var coveredFiles = ExtractCoveredClasses(fromCurrentTable, isFromMaster: false)
.Concat(ExtractCoveredClasses(fromMasterTable, isFromMaster: true));
var coverageResult = from item in coveredFiles.GroupBy(x => x.FullName)
let fromMaster = item.FirstOrDefault(x => x.IsFromMasterBranch)
let fromCurrent = item.FirstOrDefault(x => !x.IsFromMasterBranch)
select new CoveredClassReport(fromCurrent.FullName ?? fromMaster.FullName, fromCurrent.TotalCovered, fromMaster.TotalCovered);
var sb = new StringBuilder()
.AppendLine("File | Current branch coverage | Upstream branch coverage | Difference")
.AppendLine("---- | ---------------------- | ------------------------ | ----------");
foreach (var item in coverageResult.Where(x => x.CoverageDifference != 0))
{
sb.AppendLine($"{item.FullName} | {item.TotalCoveredCurrent:N} | {item.TotalCoveredMaster:N} | {item.CoverageDifference / 100:P} {item.CoverageDifferenceEmoji}");
}
var result = sb.ToString();
return(result);
}
protected override void ClientHelper_ReceivedServiceResponse(object sender, EventArgs <ServiceResponse> e)
{
List <object> attachments = e.Argument.Attachments;
// Handle any special attachments coming in from service
if (attachments != null)
{
foreach (object attachment in attachments)
{
if (attachment is ConfigurationErrorFrame)
{
Console.WriteLine("Received configuration error frame, invocation request for device configuration has failed. See common phasor services response for reason.\r\n");
}
else if (attachment is IConfigurationFrame)
{
// Attachment is a configuration frame, serialize it to XML and open it in a browser
IConfigurationFrame configurationFrame = attachment as IConfigurationFrame;
string fileName = string.Format("{0}\\DownloadedConfiguration-ID[{1}].xml", FilePath.GetAbsolutePath(""), configurationFrame.IDCode);
FileStream configFile = File.Create(fileName);
SoapFormatter xmlSerializer = new SoapFormatter();
xmlSerializer.AssemblyFormat = FormatterAssemblyStyle.Simple;
xmlSerializer.TypeFormat = FormatterTypeStyle.TypesWhenNeeded;
try
{
// Attempt to serialize configuration frame as XML
xmlSerializer.Serialize(configFile, configurationFrame);
}
catch (Exception ex)
{
byte[] errorMessage = Encoding.UTF8.GetBytes(ex.Message);
configFile.Write(errorMessage, 0, errorMessage.Length);
Console.Write("Failed to serialize configuration frame: {0}", ex.Message);
}
configFile.Close();
// Open captured XML sample file in explorer...
Process.Start("explorer.exe", fileName);
}
}
}
// Allow base class to handle common response
base.ClientHelper_ReceivedServiceResponse(sender, e);
}
public static string S3SyncDownload(this ICakeContext context, FilePath filePath, SyncSettings settings)
{
return(context.CreateManager().SyncDownload(filePath, settings));
}
public static void GenerateEncryptionKey(this ICakeContext context, FilePath filePath, int size)
{
context.CreateManager().GenerateEncryptionKey(filePath, size);
}
public static void S3Download(this ICakeContext context, FilePath filePath, string key, string version, DownloadSettings settings)
{
context.CreateManager().Download(filePath, key, version, settings);
}
public void GivenScriptExist(FilePath path, string content)
{
FileSystem.CreateFile(path).SetContent(content);
}
public bool IsWorkspaceItemFile(FilePath file)
{
return(IsWorkspaceItemFileImpl(file.ToString()));
}
static async Task Main(string[] args)
{
Parser.Default.ParseArguments <Options>(args)
.WithParsed(o => Option = o)
.WithNotParsed(o => Environment.Exit(-1));
Option.FFArgument = Option.FFArgument.Replace("\\", "");
Option.ExifArgument = Option.ExifArgument.Replace("\\", "");
List <string> ExtensionFilters = Option.Extensions.ToList();
var FilePaths = Directory.GetFiles(Option.Source, "*", SearchOption.AllDirectories)
.Where(f => ExtensionFilters.Any(e => f.EndsWith(e, StringComparison.CurrentCultureIgnoreCase)))
.ToList();
int Process_cnt = 0, Ignored_cnt = 0, Keep_cnt = 0;
var TaskList = new List <Task>();
foreach (var FilePath in FilePaths)
{
var SavePath = FilePath.Replace(Option.Source, Option.Destination);
//multi thread
if (TaskList.Count >= Option.Thread)
{
Task FinishedTask = await Task.WhenAny(TaskList);
TaskList.Remove(FinishedTask);
Interlocked.Increment(ref Process_cnt);
}
//Check Ignore
if (Option.Ignore && File.Exists(SavePath))
{
Console.WriteLine($"File exist, ignored:{SavePath}");
Interlocked.Increment(ref Ignored_cnt);
continue;//skip
}
Directory.CreateDirectory(Path.GetDirectoryName(SavePath));
Task t = Task.Run(() => {
//Check Comment
if (String.IsNullOrEmpty(Option.Comment) == false &&
Option.Comment == ReadComment(FilePath))
{
Console.WriteLine($"File already has comment, ignored:{SavePath}");
Interlocked.Increment(ref Ignored_cnt);
return;//skip
}
if (String.IsNullOrEmpty(Option.FFArgument) == false)
{
RunFFMPEG(FilePath, SavePath);
}
if (String.IsNullOrEmpty(Option.ExifArgument) == false)
{
RunExifTool(FilePath, SavePath);
}
if (String.IsNullOrEmpty(Option.Date) == false)
{
CopyDate(FilePath, SavePath);
}
if (Option.Keep && CheckFileSize(FilePath, SavePath))
{
Console.WriteLine($"Output file is larger, copy original:{SavePath}");
Interlocked.Increment(ref Keep_cnt);
}
});
TaskList.Add(t);
Console.WriteLine($"Processing:{SavePath}");
WriteOnBottomLine($"File Count:{FilePaths.Count}, Processed:{Process_cnt.ToString()}, Ignored:{Ignored_cnt.ToString()}, Keep:{Keep_cnt.ToString()}");
}
while (TaskList.Count != 0)
{
Task FinishedTask = await Task.WhenAny(TaskList);
TaskList.Remove(FinishedTask);
Interlocked.Increment(ref Process_cnt);
}
WriteOnBottomLine($"File Count:{FilePaths.Count}, Processed:{Process_cnt.ToString()}, Ignored:{Ignored_cnt.ToString()}, Keep:{Keep_cnt.ToString()}");
}
bool CopyFiles(IProgressMonitor monitor, IWorkspaceFileObject obj, IEnumerable <FilePath> files, FilePath targetBasePath, bool ignoreExternalFiles)
{
FilePath baseDir = obj.BaseDirectory.FullPath;
foreach (FilePath file in files)
{
if (!File.Exists(file))
{
monitor.ReportWarning(GettextCatalog.GetString("File '{0}' not found.", file));
continue;
}
FilePath fname = file.FullPath;
// Can't export files from outside the root solution directory
if (!fname.IsChildPathOf(baseDir))
{
if (ignoreExternalFiles)
{
continue;
}
if (obj is Solution)
{
monitor.ReportError("The solution '" + obj.Name + "' is referencing the file '" + Path.GetFileName(file) + "' which is located outside the root solution directory.", null);
}
else
{
monitor.ReportError("The project '" + obj.Name + "' is referencing the file '" + Path.GetFileName(file) + "' which is located outside the project directory.", null);
}
return(false);
}
FilePath rpath = fname.ToRelative(baseDir);
rpath = rpath.ToAbsolute(targetBasePath);
if (!Directory.Exists(rpath.ParentDirectory))
{
Directory.CreateDirectory(rpath.ParentDirectory);
}
File.Copy(file, rpath, true);
}
return(true);
}
public ScriptAnalyzerResult Analyze(FilePath script)
{
return(CreateAnalyzer().Analyze(script, new ScriptAnalyzerSettings()));
}
public async Task MonitorFileTailAsync(FilePath path,
Func <string, Task> onChange,
TimeSpan period = default,
CancellationToken cancellationToken = default)
{
if (period == default)
{
period = TimeSpan.FromSeconds(1);
}
if (!File.Exists(path))
{
throw new FileNotFoundException(path);
}
if (onChange is null)
{
throw new ArgumentNullException(nameof(onChange));
}
const int bufferLength = 4096;
var initialFileLength = new FileInfo(path).Length;
var lastReadLength = initialFileLength - bufferLength;
if (lastReadLength < 0)
{
lastReadLength = 0;
}
while (!cancellationToken.IsCancellationRequested)
{
var fileLength = new FileInfo(path).Length;
if (fileLength < lastReadLength)
{
throw new
IOException("Something was deleted from the watched file. Deletion events doesn't support now");
}
if (fileLength > lastReadLength)
{
using (var fileStream = new FileStream(path,
FileMode.Open,
FileAccess.Read,
FileShare.ReadWrite,
bufferLength,
FileOptions.Asynchronous))
{
if (!fileStream.CanSeek)
{
throw new InvalidOperationException("Can't seek the file watch stream");
}
fileStream.Seek(lastReadLength, SeekOrigin.Begin);
var buffer = new byte[bufferLength];
int bytesRead;
while ((bytesRead = await fileStream.ReadAsync(buffer, 0, buffer.Length, cancellationToken)) >
0)
{
lastReadLength += bytesRead;
var text = Encoding.ASCII.GetString(buffer, 0, bytesRead);
await onChange(text);
}
}
}
if (cancellationToken.IsCancellationRequested)
{
break;
}
await Task.Delay(period, cancellationToken);
}
}
public bool IsSolutionItemFile(FilePath file)
{
return(IsSolutionItemFileImpl(file.ToString()));
}
internal static void StartUpdatesInstaller(FilePath installerDataFile, FilePath updatedInstallerPath)
{
PlatformService.StartUpdatesInstaller(installerDataFile, updatedInstallerPath);
}
string Export(IProgressMonitor monitor, IWorkspaceFileObject obj, string[] includedChildIds, string targetPath, FileFormat format)
{
string rootSourceFile = obj.FileName;
string sourcePath = Path.GetFullPath(Path.GetDirectoryName(rootSourceFile));
targetPath = Path.GetFullPath(targetPath);
if (sourcePath != targetPath)
{
if (!CopyFiles(monitor, obj, obj.GetItemFiles(true), targetPath, true))
{
return(null);
}
string newFile = Path.Combine(targetPath, Path.GetFileName(rootSourceFile));
if (IsWorkspaceItemFile(rootSourceFile))
{
obj = ReadWorkspaceItem(monitor, newFile);
}
else
{
obj = (SolutionEntityItem)ReadSolutionItem(monitor, newFile);
}
using (obj) {
List <FilePath> oldFiles = obj.GetItemFiles(true);
ExcludeEntries(obj, includedChildIds);
if (format != null)
{
obj.ConvertToFormat(format, true);
}
obj.Save(monitor);
List <FilePath> newFiles = obj.GetItemFiles(true);
foreach (FilePath f in newFiles)
{
if (!f.IsChildPathOf(targetPath))
{
if (obj is Solution)
{
monitor.ReportError("The solution '" + obj.Name + "' is referencing the file '" + f.FileName + "' which is located outside the root solution directory.", null);
}
else
{
monitor.ReportError("The project '" + obj.Name + "' is referencing the file '" + f.FileName + "' which is located outside the project directory.", null);
}
}
oldFiles.Remove(f);
}
// Remove old files
foreach (FilePath file in oldFiles)
{
if (File.Exists(file))
{
File.Delete(file);
// Exclude empty directories
FilePath dir = file.ParentDirectory;
if (Directory.GetFiles(dir).Length == 0 && Directory.GetDirectories(dir).Length == 0)
{
try {
Directory.Delete(dir);
} catch (Exception ex) {
monitor.ReportError(null, ex);
}
}
}
}
return(obj.FileName);
}
}
else
{
using (obj) {
ExcludeEntries(obj, includedChildIds);
if (format != null)
{
obj.ConvertToFormat(format, true);
}
obj.Save(monitor);
return(obj.FileName);
}
}
}
public static void OpenFolder(FilePath folderPath)
{
PlatformService.OpenFolder(folderPath);
}
public async Task UnzipAsync(FilePath archivePath, DirectoryPath destination)
{
logAction?.Invoke($"Unzipping {archivePath} ==>> {destination}");
await Task.Run(() => ZipFile.ExtractToDirectory(archivePath, destination));
}
public bool IsSolutionItemFile(FilePath file)
{
return(FileIsObjectOfType(file, typeof(SolutionItem)));
}
public static void OpenInTerminal(FilePath directory)
{
PlatformService.OpenInTerminal(directory);
}
async Task <string> Export(ProgressMonitor monitor, IMSBuildFileObject obj, string[] includedChildIds, string targetPath, MSBuildFileFormat format)
{
string rootSourceFile = obj.FileName;
string sourcePath = Path.GetFullPath(Path.GetDirectoryName(rootSourceFile));
targetPath = Path.GetFullPath(targetPath);
if (sourcePath != targetPath)
{
if (!CopyFiles(monitor, obj, obj.GetItemFiles(true), targetPath, true))
{
return(null);
}
string newFile = Path.Combine(targetPath, Path.GetFileName(rootSourceFile));
if (IsWorkspaceItemFile(rootSourceFile))
{
obj = (Solution) await ReadWorkspaceItem(monitor, newFile);
}
else
{
obj = await ReadSolutionItem(monitor, newFile);
}
using (obj) {
var oldFiles = obj.GetItemFiles(true).ToList();
ExcludeEntries(obj, includedChildIds);
if (format != null)
{
obj.ConvertToFormat(format);
}
await obj.SaveAsync(monitor);
var newFiles = obj.GetItemFiles(true);
var resolvedTargetPath = new FilePath(targetPath).ResolveLinks().FullPath;
foreach (FilePath f in newFiles)
{
if (!f.IsChildPathOf(resolvedTargetPath))
{
if (obj is Solution)
{
monitor.ReportError(GettextCatalog.GetString("The solution '{0}' is referencing the file '{1}' which is located outside the root solution directory.", obj.Name, f.FileName), null);
}
else
{
monitor.ReportError(GettextCatalog.GetString("The project '{0}' is referencing the file '{1}' which is located outside the project directory.", obj.Name, f.FileName), null);
}
}
oldFiles.Remove(f);
}
// Remove old files
foreach (FilePath file in oldFiles)
{
if (File.Exists(file))
{
File.Delete(file);
// Exclude empty directories
FilePath dir = file.ParentDirectory;
if (Directory.GetFiles(dir).Length == 0 && Directory.GetDirectories(dir).Length == 0)
{
try {
Directory.Delete(dir);
} catch (Exception ex) {
monitor.ReportError(null, ex);
}
}
}
}
return(obj.FileName);
}
}
else
{
using (obj) {
ExcludeEntries(obj, includedChildIds);
if (format != null)
{
obj.ConvertToFormat(format);
}
await obj.SaveAsync(monitor);
return(obj.FileName);
}
}
}
public bool IsWorkspaceItemFile(FilePath file)
{
return(FileIsObjectOfType(file, typeof(WorkspaceItem)));
}
internal static string FromMSBuildPathRelative(string basePath, string relPath)
{
FilePath file = FromMSBuildPath(basePath, relPath);
return(file.ToRelative(basePath));
}
public bool FileIsObjectOfType(FilePath file, Type type)
{
var filename = GetTargetFile(file);
return(GetObjectReaderForFile(filename, type) != null);
}
/// <summary>
/// Load sprite data from a sprite sheet
/// </summary>
/// <param name="filePath"></param>
/// <param name="textureLoader"></param>
/// <returns></returns>
public SpriteDataCollection LoadSpriteSheet(FilePath filePath, ITextureLoader textureLoader)
{
var result = new SpriteDataCollection();
using (var br = new StreamReader(filePath))
{
//Read line-by-line:
SpriteData currentSprite = null;
SpriteAnimation currentAnimation = null;
SpriteAnimationDirection currentDirection = null;
ITexture image = null;
String line = br.ReadLine();
if (line != null)
{
//First line gives image filename
image = textureLoader.GetTexture(filePath.Directory + line);
}
while (line != null)
{
line = br.ReadLine();
if (string.IsNullOrWhiteSpace(line))
{
//Store and clear current sprite data:
if (currentSprite != null)
{
result.Add(currentSprite);
}
currentSprite = null;
currentAnimation = null;
}
else
{
String[] splitLine = line.Split('\t'); // Split on tabs
if (currentSprite == null)
{
//Initialise sprite:
currentSprite = new SpriteData();
currentSprite.Name = line;
//currentSprite.Texture(image);
}
else if (currentAnimation == null || !splitLine.IsNumeric())
{
currentAnimation = new SpriteAnimation();
currentSprite.Animations.Add(line, currentAnimation);
currentDirection = null;
}
else if (currentDirection == null || splitLine.Length <= 1)
{
currentDirection = new SpriteAnimationDirection();
currentAnimation.Directions.Add(double.Parse(line), currentDirection);
}
else
{
TextureBrush frame = new TextureBrush(image, splitLine);
currentDirection.Frames.Add(frame);
}
}
}
}
return(result);
}
public IFile GetFile(FilePath path)
{
return(new LongPathFile(path));
}
public ViewContent CreateContent(FilePath fileName, string mimeType, Project ownerProject)
{
return(new DotDesktopView());
}
internal static string ToMSBuildPathRelative(string baseDirectory, string absPath)
{
FilePath file = ToMSBuildPath(baseDirectory, absPath);
return(file.ToRelative(baseDirectory));
}
public bool CanHandle(FilePath fileName, string mimeType, Project ownerProject)
{
return((fileName.IsNotNull && fileName.HasExtension(".desktop")) ||
(mimeType != null && mimeType == "application/x-desktop"));
}
/// <exception cref="System.IO.IOException"/>
public virtual void TestFailAbort()
{
JobConf job = new JobConf();
job.Set(FileSystem.FsDefaultNameKey, "faildel:///");
job.SetClass("fs.faildel.impl", typeof(TestMRCJCFileOutputCommitter.FakeFileSystem
), typeof(FileSystem));
SetConfForFileOutputCommitter(job);
JobContext jContext = new JobContextImpl(job, ((JobID)taskID.GetJobID()));
TaskAttemptContext tContext = new TaskAttemptContextImpl(job, taskID);
FileOutputCommitter committer = new FileOutputCommitter();
FileOutputFormat.SetWorkOutputPath(job, committer.GetTaskAttemptPath(tContext));
// do setup
committer.SetupJob(jContext);
committer.SetupTask(tContext);
string file = "test.txt";
FilePath jobTmpDir = new FilePath(committer.GetJobAttemptPath(jContext).ToUri().GetPath
());
FilePath taskTmpDir = new FilePath(committer.GetTaskAttemptPath(tContext).ToUri()
.GetPath());
FilePath expectedFile = new FilePath(taskTmpDir, file);
// A reporter that does nothing
Reporter reporter = Reporter.Null;
// write output
FileSystem localFs = new TestMRCJCFileOutputCommitter.FakeFileSystem();
TextOutputFormat theOutputFormat = new TextOutputFormat();
RecordWriter theRecordWriter = theOutputFormat.GetRecordWriter(localFs, job, expectedFile
.GetAbsolutePath(), reporter);
WriteOutput(theRecordWriter, reporter);
// do abort
Exception th = null;
try
{
committer.AbortTask(tContext);
}
catch (IOException ie)
{
th = ie;
}
NUnit.Framework.Assert.IsNotNull(th);
NUnit.Framework.Assert.IsTrue(th is IOException);
NUnit.Framework.Assert.IsTrue(th.Message.Contains("fake delete failed"));
NUnit.Framework.Assert.IsTrue(expectedFile + " does not exists", expectedFile.Exists
());
th = null;
try
{
committer.AbortJob(jContext, JobStatus.State.Failed);
}
catch (IOException ie)
{
th = ie;
}
NUnit.Framework.Assert.IsNotNull(th);
NUnit.Framework.Assert.IsTrue(th is IOException);
NUnit.Framework.Assert.IsTrue(th.Message.Contains("fake delete failed"));
NUnit.Framework.Assert.IsTrue("job temp dir does not exists", jobTmpDir.Exists());
}
