// ExternalTokenHelperPath takes the configured path to a helper and expands it to // a full absolute path that can be executed. As of 0.5, the default token // helper is internal, to avoid problems running in dev mode (see GH-850 and // GH-783), so special assumptions of prepending "vault token-" no longer // apply. // // As an additional result, only absolute paths are now allowed. Looking in the // path or a current directory for an arbitrary executable could allow someone // to switch the expected binary for one further up the path (or in the current // directory), potentially opening up execution of an arbitrary binary. //~ func ExternalTokenHelperPath(path string) (string, error) { public static string ExternalTokenHelperPath(string path) { //~ if !filepath.IsAbs(path) { //~ var err error //~ path, err = filepath.Abs(path) //~ if err != nil { //~ return "", err //~ } //~ } if (!IOPath.IsPathRooted(path)) { path = IOPath.GetFullPath(path); } //~ if _, err := os.Stat(path); err != nil { //~ return "", fmt.Errorf("unknown error getting the external helper path") //~ } //~ //~ return path, nil if (File.Exists(path)) { new FileInfo(path); } else if (Directory.Exists(path)) { new DirectoryInfo(path); } else { throw new System.IO.FileNotFoundException(); } return(path); }
public static string GetPath(string name) { var key = name.ToLower(); if (UserPaths.ContainsKey(key)) { if (Path.IsPathRooted(UserPaths[key])) { return(UserPaths[key]); } return(Path.GetFullPath(RootPath + Path.DirectorySeparatorChar + UserPaths[key])); } if (Paths.ContainsKey(key)) { if (Path.IsPathRooted(Paths[key])) { return(Paths[key]); } return(Path.GetFullPath(RootPath + Path.DirectorySeparatorChar + Paths[key])); } var stackTrace = new StackTrace(); var method = stackTrace.GetFrame(1).GetMethod(); Debug.Log("Configuration", "Path \"" + name + "\" is not present. (called by: " + method.DeclaringType.FullName + "::" + method.Name + ")", Debug.Type.Warning); return(""); }
public static string GetPath(string res) { if (IOPath.IsPathRooted(res)) { return(res); } foreach (AppFW.ResourceManager.Category category in Enum.GetValues(typeof(AppFW.ResourceManager.Category))) { var path = AppFW.ResourceManager.TryGetPath(category, res); if (path != null) { return(path); } } AppFW.Application app = AppFW.Application.Current; if (app != null) { string resPath = app.DirectoryInfo.Resource + res; if (File.Exists(resPath)) { return(resPath); } } return(res); }
/// <summary>If the <paramref name="fileName "/> value points to a file in %windir%\system32 and the equivalent file exists in SysWow64 it will return the path to that file, otherwise null.</summary> public static String GetSysWow64File(String fileName) { if (_resolvedSystem32Path == null) { _resolvedSystem32Path = ResolvePath(@"%windir%\system32"); _resolvedSysWow64Path = ResolvePath(@"%windir%\SysWow64"); _resolvedProgFilePath = ResolvePath(@"%programfiles%"); // this also covers %commonprogramfiles% and %commonprogramfiles(x86)% _resolvedPrgFle32Path = ResolvePath(@"%programfiles(x86)%"); } if (!Path.IsPathRooted(fileName)) { return(null); } /////////////////////////////////////// if (fileName.StartsWith(_resolvedSystem32Path, StringComparison.OrdinalIgnoreCase)) { String relativePath = fileName.Substring(_resolvedSystem32Path.Length); if (relativePath.StartsWith("\\", StringComparison.OrdinalIgnoreCase)) { relativePath = relativePath.Substring(1); } fileName = Path.Combine(_resolvedSysWow64Path, relativePath); if (File.Exists(fileName)) { return(fileName); } } /////////////////////////////////////// if (fileName.StartsWith(_resolvedProgFilePath, StringComparison.OrdinalIgnoreCase)) { String relativePath = fileName.Substring(_resolvedProgFilePath.Length); if (relativePath.StartsWith("\\")) { relativePath = relativePath.Substring(1); } fileName = Path.Combine(_resolvedPrgFle32Path, relativePath); if (File.Exists(fileName)) { return(fileName); } } /////////////////////////////////////// return(null); }
private string GetFullPath(string path) { if (!IOPath.IsPathRooted(path) && _options.FileSystem.CurrentDirectory != null) { path = IOPath.Combine(_options.FileSystem.CurrentDirectory, path); } return(IOPath.GetFullPath(path)); }
internal string GetAbsolutePath(string path) { if (Path.IsPathRooted(path)) { return(path); } return(Path.Combine(_workingDirectory, path)); }
private static string GetFullPath(string path) { if (!IOPath.IsPathRooted(path) && AppDomain.CurrentDomain.BaseDirectory != null) { path = IOPath.Combine(AppDomain.CurrentDomain.BaseDirectory, path); } return IOPath.GetFullPath(path).ToUpperInvariant(); }
private static string GetPath(bool makeAbsolute, string filePath, string absBasePath) { string absFilePath = Path.IsPathRooted(filePath) ? filePath : new FileInfo(Path.Combine(absBasePath, filePath)).FullName; return(makeAbsolute ? absFilePath : Path.GetRelativePath(absBasePath, absFilePath)); }
/// <summary>Resolves environment variables inside a path</summary> /// <param name="root">If the resolved path is not rooted, this parameter will be intelligently prepended</param> public static String ResolvePath(String path, String root) { String resolved = Environment.ExpandEnvironmentVariables(path); if (Path.IsPathRooted(resolved)) { return(resolved); } return(Path.Combine(root, resolved)); /* * * if( path.IndexOf('%') == -1 ) return path; * * StringBuilder retval = new StringBuilder(); * StringBuilder currentEnvVar = new StringBuilder(); * * Boolean inEnvVar = false; * for(int i=0;i<path.Length;i++) { * Char c = path[i]; * * if(c == '%') inEnvVar = !inEnvVar; * if(c == '%' && inEnvVar) { * inEnvVar = path.IndexOf('%', i) > -1; // it doesn't count if there isn't another % in the string later on * if(inEnvVar) continue; // no point logging the % character * } * if(c == '%' && !inEnvVar) { * continue; * } * * if(!inEnvVar) retval.Append( c ); * else { * * currentEnvVar.Append( c ); * * if( path[i+1] == '%' ) { // if we're at the end of an envvar; // TODO: How do I avoid an indexoutofrange? * // actually, I don't think this will happen since the check above means we won't be inEnvVar if there isn't another one in the string * * String envVar = currentEnvVar.ToString(); currentEnvVar.Length = 0; * retval.Append( Environment.GetEnvironmentVariable( envVar ) ); * * } * } * } * * String ret = retval.ToString(); * * if( !Path.IsPathRooted( ret ) ) { * * ret = Path.Combine( root, ret ); * } * * return ret; */ }
private void SelectFfmpeg_Click(object sender, RoutedEventArgs e) { var output = UserSettings.All.FfmpegLocation ?? ""; if (output.ToCharArray().Any(x => Path.GetInvalidPathChars().Contains(x))) { output = ""; } //It's only a relative path if not null/empty and there's no root folder declared. var isRelative = !string.IsNullOrWhiteSpace(output) && !Path.IsPathRooted(output); var notAlt = !string.IsNullOrWhiteSpace(output) && (UserSettings.All.FfmpegLocation ?? "").Contains(Path.DirectorySeparatorChar); //Gets the current directory folder, where the file is located. If empty, it means that the path is relative. var directory = !string.IsNullOrWhiteSpace(output) ? Path.GetDirectoryName(output) : ""; if (!string.IsNullOrWhiteSpace(output) && string.IsNullOrWhiteSpace(directory)) { directory = AppDomain.CurrentDomain.BaseDirectory; } var initial = Directory.Exists(directory) ? directory : Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory); var ofd = new OpenFileDialog { FileName = "ffmpeg", Filter = "FFmpeg executable (*.exe)|*.exe", //TODO: Localize. Title = LocalizationHelper.Get("Extras.FfmpegLocation.Select"), InitialDirectory = isRelative ? Path.GetFullPath(initial) : initial, DefaultExt = ".exe" }; var result = ofd.ShowDialog(); if (!result.HasValue || !result.Value) { return; } UserSettings.All.FfmpegLocation = ofd.FileName; //Converts to a relative path again. if (isRelative && !string.IsNullOrWhiteSpace(UserSettings.All.FfmpegLocation)) { var selected = new Uri(UserSettings.All.FfmpegLocation); var baseFolder = new Uri(AppDomain.CurrentDomain.BaseDirectory); var relativeFolder = Uri.UnescapeDataString(baseFolder.MakeRelativeUri(selected).ToString()); //This app even returns you the correct slashes/backslashes. UserSettings.All.FfmpegLocation = notAlt ? relativeFolder : relativeFolder.Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar); } CheckTools(); }
private void NavigateFile(string file) { if (!Path.IsPathRooted(file)) { file = Path.GetFullPath(Path.Combine(((App)Application.Current).RootPath, this.ViewModel.Profile.ProjectName, "Config", file)); } if (!File.Exists(file)) { return; } Process.Start("explorer.exe", $"/select, \"{file}\""); }
public void OpenFiles(string[] fileNames) { foreach (var f in fileNames) { try { WaitingVisible = Visibility.Visible; string file = f; if (!Path.IsPathRooted(f)) { file = Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar + f; } var t = _epubService.OpenFileAsync(file); t.ContinueWith(t1 => { try { if (t1.Result != null) { int index = (int)t1.Result; Nodes.Add(_epubService.EpubList[index].TocNode); for (int i = 0; i < Nodes.Count; i++) { Nodes[i].IsExpanded = false; } Nodes[index].IsExpanded = true; Nodes[index].IsSelected = true; TocSelectedItemChanged(new RoutedPropertyChangedEventArgs <object>(null, Nodes[index])); //Nodes[0].Icon = ItemNode.ExpandedIcon; if (_epubService.EpubList.Count > 0 && _epubService.EpubList[0].IsSpine) { ((ContentTabItemViewModel)ActiveItem).UseDocumentTitle = true; } } } catch (Exception) { } finally { WaitingVisible = Visibility.Collapsed; } }, TaskScheduler.Default);// TaskScheduler.FromCurrentSynchronizationContext()); } catch (Exception ex) { MessageBox.Show(ex.Message); WaitingVisible = Visibility.Collapsed; } } }
/// <summary> /// Takes the picture. /// </summary> /// <param name="options">The storage options.</param> /// <returns>Task representing the asynchronous operation.</returns> /// <exception cref="NotSupportedException">No camera is present on the current device.</exception> public override Task <MediaFile> TakePhotoAsync(CameraMediaStorageOptions options) { // If no camera available if (!this.IsCameraAvailable) { throw new NotSupportedException(); } // Validate options if (options == null) { throw new ArgumentNullException(nameof(options)); } // If path is rooted if (Path.IsPathRooted(options.Directory)) { throw new ArgumentException("options.Directory must be a relative folder"); } // Take the photo return(this.TakeMediaAsync("image/*", MediaStore.ActionImageCapture, options)); }
/// <summary> /// Gets the size of the image from file /// </summary> /// <param name="file">The path of the file containing image</param> /// <returns></returns> public static Size GetImageSize(string file) { if (!Path.IsPathRooted(file)) { file = System.Web.HttpContext.Current.Request.MapPath(file); } if (File.Exists(file)) { Bitmap b = null; try { b = new Bitmap(file); return(b.Size); } finally { if (b != null) { b.Dispose(); } } } return(Size.Empty); }
public static string AbsolutePath(string path, string hintPath = null) { //If the path is absolute path no need to transform. if (Path.IsPathRooted(path)) { return(path); } var session = Dynamo.Events.ExecutionEvents.ActiveSession; if (session != null && !string.IsNullOrEmpty(session.CurrentWorkspacePath)) { var parent = Path.GetDirectoryName(session.CurrentWorkspacePath); var filepath = Path.Combine(parent, path); //If hint path is null or file exists at this location return the computed path //If hint path doesn't exist then the relative path might be for write operation. if (FileSystem.FileExists(filepath) || string.IsNullOrEmpty(hintPath) || !FileSystem.FileExists(hintPath)) { return(Path.GetFullPath(filepath)); } } return(string.IsNullOrEmpty(hintPath) ? path : hintPath); }
public static List <DropMatch> FromDropData(string rootPath, string targetPath, FileBrowserManager fileBrowserManager, FilesDragEventArgs e) { if (rootPath == null) { throw new ArgumentNullException(nameof(rootPath)); } if (targetPath == null) { throw new ArgumentNullException(nameof(targetPath)); } if (e == null) { throw new ArgumentNullException(nameof(e)); } FilesDropData dropData = e.DropData; if (dropData == null) { throw new ArgumentNullException(nameof(dropData)); } var matches = new List <DropMatch>(); for (int i = 0; i < dropData.FileNames.Length; i++) { string fileName = dropData.FileNames[i]; if (!IOPath.IsPathRooted(fileName)) { // Normal drag/drop operations have the full path. Drag/drop operations // without a full path generally are Ole objects that don't point to // physical files, like drag/dropping from an Outlook email or a Windows // compressed folder. To get the data, matches.Add(new DropMatch(fileName, i, DropMatchKind.FileVirtual)); continue; } var fileInfo = new FileInfo(fileName); if (fileInfo.Attributes.IsHidden()) { continue; } bool contained = PathUtil.ContainsPath(rootPath, fileInfo.FullName) != PathContains.Not; bool ctrlKeyPressed = (e.KeyState & 8) != 0; bool shiftKeyPressed = (e.KeyState & 4) != 0; if (PathUtil.ContainsPath(targetPath, fileInfo.DirectoryName) == PathContains.Equals) { continue; } if (fileInfo.Attributes.IsDirectory()) { if (Directory.Exists(IOPath.Combine(targetPath, fileInfo.Name))) { continue; } if (PathUtil.ContainsPath(fileInfo.FullName, targetPath) != PathContains.Not) { continue; } var kind = contained ? DropMatchKind.DirectoryMove : DropMatchKind.DirectoryCopy; if (ctrlKeyPressed && kind == DropMatchKind.DirectoryMove) { kind = DropMatchKind.DirectoryCopy; } else if (shiftKeyPressed && kind == DropMatchKind.DirectoryCopy) { kind = DropMatchKind.DirectoryMove; } matches.Add(new DropMatch(fileInfo.FullName, i, kind)); } else if (fileBrowserManager != null && fileBrowserManager.Matches(fileInfo.FullName)) { var kind = contained ? DropMatchKind.FileMove : DropMatchKind.FileCopy; if (ctrlKeyPressed && kind == DropMatchKind.FileMove) { kind = DropMatchKind.FileCopy; } else if (shiftKeyPressed && kind == DropMatchKind.FileCopy) { kind = DropMatchKind.FileMove; } matches.Add(new DropMatch(fileInfo.FullName, i, kind)); } } return(matches); }
static bool IsEmbeddedResourcePath(string path) { var separatorIndex = path.IndexOf(AssemblySeparator); return(separatorIndex >= 0 && !SystemPath.IsPathRooted(path)); }
/// <summary> /// This helper method can be used to convert a relative path to an absolute path based on the given base /// path. /// </summary> /// <param name="basePath">The base path</param> /// <param name="relativePath">A relative path</param> /// <returns>An absolute path</returns> /// <remarks>If the base path is null or empty, the current working folder is used.</remarks> /// <example> /// <code lang="cs"> /// string basePath = @"E:\DotNet\CS\TestProject\Source"; /// string relativePath = @"..\Doc\Help.html"; /// /// string absolutePath = FilePath.RelativeToAbsolutePath(basePath, /// relativePath); /// /// Console.WriteLine(absolutePath); /// /// // Results in: E:\DotNet\CS\TestProject\Doc\Help.html /// </code> /// <code lang="vbnet"> /// Dim basePath As String = "E:\DotNet\CS\TestProject\Source" /// Dim relativePath As String = "..\Doc\Help.html" /// /// Dim absolutePath As String = _ /// FilePath.RelativeToAbsolutePath(basePath, relativePath); /// /// Console.WriteLine(absolutePath) /// /// ' Results in: E:\DotNet\CS\TestProject\Doc\Help.html /// </code> /// </example> public static string RelativeToAbsolutePath(string basePath, string relativePath) { int idx; // If blank return the base path if (String.IsNullOrEmpty(relativePath)) { return(basePath); } // Don't bother if already absolute if (IOPath.IsPathRooted(relativePath)) { return(relativePath); } // If not specified, use the current folder as the base path if (basePath == null || basePath.Trim().Length == 0) { basePath = Directory.GetCurrentDirectory(); } else { basePath = IOPath.GetFullPath(basePath); } // Remove trailing backslashes for comparison if (FolderPath.IsPathTerminated(basePath)) { basePath = basePath.Substring(0, basePath.Length - 1); } if (relativePath == ".") { relativePath = String.Empty; } // Remove ".\" or "./" if it's there if (relativePath.Length > 1 && relativePath[0] == '.' && (relativePath[1] == IOPath.DirectorySeparatorChar || relativePath[1] == IOPath.AltDirectorySeparatorChar)) { relativePath = relativePath.Substring(2); } // Split the paths into their component parts string[] baseParts = basePath.Split(IOPath.DirectorySeparatorChar); string[] relParts = relativePath.Split(IOPath.DirectorySeparatorChar); // Figure out how far to move up from the relative path for (idx = 0; idx < relParts.Length; ++idx) { if (relParts[idx] != "..") { break; } } // If it's below the base path, just add it to the base path if (idx == 0) { return(FilePath.GetFullPath(basePath + IOPath.DirectorySeparatorChar + relativePath)); } string absPath = String.Join(IOPath.DirectorySeparatorChar.ToString(), baseParts, 0, Math.Max(0, baseParts.Length - idx)); absPath += IOPath.DirectorySeparatorChar + String.Join(IOPath.DirectorySeparatorChar.ToString(), relParts, idx, relParts.Length - idx); return(FilePath.GetFullPath(absPath)); }
/// <summary> /// This helper method can be used to convert an absolute path to one that is relative to the given base /// path. /// </summary> /// <param name="basePath">The base path</param> /// <param name="absolutePath">An absolute path</param> /// <returns>A path to the given absolute path that is relative to the given base path</returns> /// <remarks>If the base path is null or empty, the current working folder is used.</remarks> /// <example> /// <code lang="cs"> /// string basePath = @"E:\DotNet\CS\TestProject\Source"; /// string absolutePath = @"E:\DotNet\CS\TestProject\Doc\Help.html"; /// /// string relativePath = FilePath.AbsoluteToRelativePath(basePath, /// absolutePath); /// /// Console.WriteLine(relativePath); /// /// // Results in: ..\Doc\Help.html /// </code> /// <code lang="vbnet"> /// Dim basePath As String = "E:\DotNet\CS\TestProject\Source" /// Dim absolutePath As String = "E:\DotNet\CS\TestProject\Doc\Help.html" /// /// Dim relativePath As String = _ /// FilePath.AbsoluteToRelativePath(basePath, absolutePath); /// /// Console.WriteLine(relativePath) /// /// ' Results in: ..\Doc\Help.html /// </code> /// </example> public static string AbsoluteToRelativePath(string basePath, string absolutePath) { bool hasBackslash = false; string relPath; int minLength, idx; // If not specified, use the current folder as the base path if (basePath == null || basePath.Trim().Length == 0) { basePath = Directory.GetCurrentDirectory(); } else { basePath = IOPath.GetFullPath(basePath); } if (absolutePath == null) { absolutePath = String.Empty; } // Just in case, make sure the path is absolute if (!IOPath.IsPathRooted(absolutePath)) { absolutePath = FilePath.GetFullPath(absolutePath); } // Remove trailing backslashes for comparison if (FolderPath.IsPathTerminated(basePath)) { basePath = basePath.Substring(0, basePath.Length - 1); } if (FolderPath.IsPathTerminated(absolutePath)) { absolutePath = absolutePath.Substring(0, absolutePath.Length - 1); hasBackslash = true; } // Split the paths into their component parts char[] separators = { IOPath.DirectorySeparatorChar, IOPath.AltDirectorySeparatorChar, IOPath.VolumeSeparatorChar }; string[] baseParts = basePath.Split(separators); string[] absParts = absolutePath.Split(separators); // Find the common base path minLength = Math.Min(baseParts.Length, absParts.Length); for (idx = 0; idx < minLength; idx++) { if (String.Compare(baseParts[idx], absParts[idx], StringComparison.OrdinalIgnoreCase) != 0) { break; } } // Use the absolute path if there's nothing in common (i.e. they are on different drives or network // shares. if (idx == 0) { relPath = absolutePath; } else { // If equal to the base path, it doesn't have to go anywhere. Otherwise, work up from the base // path to the common root. if (idx == baseParts.Length) { relPath = String.Empty; } else { relPath = new String(' ', baseParts.Length - idx).Replace(" ", ".." + IOPath.DirectorySeparatorChar); } // And finally, add the path from the common root to the absolute path relPath += String.Join(IOPath.DirectorySeparatorChar.ToString(), absParts, idx, absParts.Length - idx); } return((hasBackslash) ? FolderPath.TerminatePath(relPath) : relPath); }
private void LoadPage(string filename, bool isBacklink = false) { string text = ""; try { // adjust path if not rooted (working directory is different when a file was opened with double click) if (!Path.IsPathRooted(filename)) { var dir = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location); filename = dir + "\\" + filename; } // load text from file text = File.ReadAllText(filename); } catch (Exception) { models.Window.ShowErrorDialog("Could not open " + filename); Close(); IsValid = false; return; } curDirectory = Path.GetFullPath(Path.GetDirectoryName(filename)); curDirectory += '/'; var fileDirectory = curDirectory.Replace('\\', '/'); fileDirectory = "file:///" + fileDirectory + "/"; // correct links text = text.Replace("![](", "![](" + fileDirectory); // add back link if (history.Count > 0) { text += "\n[Back](back)"; } history.Push(filename); //var pipe = new MarkdownPipeline(); // convert markup into htm var pipe = new Markdig.MarkdownPipelineBuilder().UseAdvancedExtensions().Build(); var html = Markdig.Markdown.ToHtml(text, pipe); // get correct pixel colors var bg = (SolidColorBrush)FindResource("BackgroundBrush"); var fg = (SolidColorBrush)FindResource("FontBrush"); var bgCol = new byte[] { bg.Color.R, bg.Color.G, bg.Color.B }; var fgCol = new byte[] { fg.Color.R, fg.Color.G, fg.Color.B }; var bgColString = BitConverter.ToString(bgCol).Replace("-", String.Empty); var fgColString = BitConverter.ToString(fgCol).Replace("-", String.Empty); html = $@" <body style=""background-color:#{bgColString}; color:#{fgColString};""> {html} </body> "; // display markup in browser Browser.NavigateToString(html); }
private string ResolveAssemblyName(string assembly, bool isForReferenceAssembly) { // if it's a path, resolve it if (assembly.Contains(PathType.DirectorySeparatorChar) || assembly.Contains(PathType.AltDirectorySeparatorChar)) { if (PathType.IsPathRooted(assembly)) { return(assembly); } else { var paths = SessionState.Path.GetResolvedPSPathFromPSPath(assembly); return(paths[0].Path); } } string refAssemblyDll = assembly; if (!assembly.EndsWith(".dll", StringComparison.OrdinalIgnoreCase)) { // It could be a short assembly name or a full assembly name, but we // always want the short name to find the corresponding assembly file. var assemblyName = new AssemblyName(assembly); refAssemblyDll = assemblyName.Name + ".dll"; } // We look up in reference/framework only when it's for resolving reference assemblies. // In case of 'Add-Type -AssemblyName' scenario, we don't attempt to resolve against framework assemblies because // 1. Explicitly loading a framework assembly usually is not necessary in PowerShell Core. // 2. A user should use assembly name instead of path if they want to explicitly load a framework assembly. if (isForReferenceAssembly) { // If it's for resolving a reference assembly, then we look in NetCoreApp ref assemblies first string netcoreAppRefPath = PathType.Combine(s_netcoreAppRefFolder, refAssemblyDll); if (File.Exists(netcoreAppRefPath)) { return(netcoreAppRefPath); } // Look up the assembly in the framework folder. This may happen when assembly is not part of // NetCoreApp, but comes from an additional package, such as 'Json.Net'. string frameworkPossiblePath = PathType.Combine(s_frameworkFolder, refAssemblyDll); if (File.Exists(frameworkPossiblePath)) { return(frameworkPossiblePath); } // The assembly name may point to a third-party assembly that is already loaded at run time. if (!assembly.EndsWith(".dll", StringComparison.OrdinalIgnoreCase)) { Assembly result = LoadAssemblyHelper(assembly); if (result != null) { return(result.Location); } } } // Look up the assembly in the current folder string currentFolderPath = SessionState.Path.GetResolvedPSPathFromPSPath(refAssemblyDll)[0].Path; if (File.Exists(currentFolderPath)) { return(currentFolderPath); } ErrorRecord errorRecord = new ErrorRecord( new Exception( String.Format(ParserStrings.ErrorLoadingAssembly, assembly)), "ErrorLoadingAssembly", ErrorCategory.InvalidOperation, assembly); ThrowTerminatingError(errorRecord); return(null); }
public static (ImmutableArray <PythonLibraryPath> interpreterPaths, ImmutableArray <PythonLibraryPath> userPaths) ClassifyPaths( string root, IFileSystem fs, IEnumerable <PythonLibraryPath> fromInterpreter, IEnumerable <string> fromUser ) { #if DEBUG Debug.Assert(root == null || root.PathEquals(PathUtils.NormalizePathAndTrim(root))); Debug.Assert(!fromInterpreter.Any(p => !p.Path.PathEquals(PathUtils.NormalizePathAndTrim(p.Path)))); #endif // Clean up user configured paths. // 1) Normalize paths. // 2) If a path isn't rooted, then root it relative to the workspace root. If there is no root, just continue. // 3) Trim off any ending separators for consistency. // 4) Remove any empty paths, FS root paths (bad idea), or paths equal to the root. // 5) Deduplicate, preserving the order specified by the user. var fromUserList = fromUser .Select(PathUtils.NormalizePath) .Select(p => root == null || IOPath.IsPathRooted(p) ? p : IOPath.GetFullPath(IOPath.Combine(root, p))) // TODO: Replace with GetFullPath(p, root) when .NET Standard 2.1 is out. .Select(PathUtils.TrimEndSeparator) .Where(p => !string.IsNullOrWhiteSpace(p) && p != "/" && !p.PathEquals(root)) .Distinct(PathEqualityComparer.Instance) .ToList(); // Remove any interpreter paths specified in the user config so they can be reclassified. // The user list is usually small; List.Contains should not be too slow. fromInterpreter.Where(p => !fromUserList.Contains(p.Path, PathEqualityComparer.Instance)) .Split(p => p.Type == PythonLibraryPathType.StdLib, out var stdlib, out var withoutStdlib); // Pull out stdlib paths, and make them always be interpreter paths. var interpreterPaths = stdlib; var userPaths = ImmutableArray <PythonLibraryPath> .Empty; var allPaths = fromUserList.Select(p => new PythonLibraryPath(p)) .Concat(withoutStdlib.Where(p => !p.Path.PathEquals(root))); foreach (var p in allPaths) { // If path is within a stdlib path, then treat it as interpreter. if (stdlib.Any(s => fs.IsPathUnderRoot(s.Path, p.Path))) { interpreterPaths = interpreterPaths.Add(p); continue; } // If Python says it's site, then treat is as interpreter. if (p.Type == PythonLibraryPathType.Site) { interpreterPaths = interpreterPaths.Add(p); continue; } // If path is outside the workspace, then treat it as interpreter. if (root == null || !fs.IsPathUnderRoot(root, p.Path)) { interpreterPaths = interpreterPaths.Add(p); continue; } userPaths = userPaths.Add(p); } return(interpreterPaths, userPaths); }
/// <summary> /// This is used to recursively load help page definitions /// </summary> /// <param name="page">The help page to load</param> /// <param name="root">The root tree node to which the page is added. If null, it is added as a root /// page.</param> /// <param name="sandcastleDate">The Sandcastle version</param> private void AddHelpPage(XElement page, TreeViewItem root, string sandcastleVersion) { Assembly asm = Assembly.GetExecutingAssembly(); IInstallerPage pageInstance; TreeViewItem node; Type pageType; string value; // Load the assembly? if (page.Attribute("assembly") != null) { value = page.Attribute("assembly").Value.Trim(); if (!String.IsNullOrEmpty(value) && !IOPath.IsPathRooted(value)) { value = IOPath.Combine(Utility.BasePath, value); } if (!String.IsNullOrEmpty(value) && !assemblies.ContainsKey(value)) { if (!File.Exists(value)) { MessageBox.Show("Unable to load installer page assembly: " + value, ApplicationTitle, MessageBoxButton.OK, MessageBoxImage.Error); return; } assemblies.Add(value, Assembly.LoadFrom(value)); } if (!String.IsNullOrEmpty(value)) { asm = assemblies[value]; } } if (page.Attribute("type") == null) { throw new InvalidOperationException("Invalid installer page definition. Missing type name."); } value = page.Attribute("type").Value.Trim(); pageType = asm.GetType(value); if (pageType == null) { MessageBox.Show("Unable to load installer page type: " + value, ApplicationTitle, MessageBoxButton.OK, MessageBoxImage.Error); return; } pageInstance = (IInstallerPage)Activator.CreateInstance(pageType); pageInstance.Installer = this; pageInstance.SandcastleVersion = sandcastleVersion; pageInstance.Initialize(page); pageInstance.Control.Visibility = Visibility.Collapsed; node = new TreeViewItem(); node.Header = pageInstance.PageTitle; node.IsExpanded = true; node.Name = String.Format(CultureInfo.InvariantCulture, "P_{0}", allPages.Count); if (root == null) { tvPages.Items.Add(node); } else { root.Items.Add(node); } allPages.Add(pageInstance); pnlPages.Children.Add(pageInstance.Control); foreach (var childPage in page.Elements("page")) { this.AddHelpPage(childPage, node, sandcastleVersion); } }
private void convertButton_Click(object sender, RoutedEventArgs e) { var uwpSolutionFileLocation = uwpSolutionLocationTextBox.Text; if (string.IsNullOrWhiteSpace(uwpSolutionFileLocation) && !Path.IsPathRooted(uwpSolutionFileLocation)) { MessageBox.Show("A valid Unity UWP Solution file must be provided.\nIt is the .sln file created by Unity when building for the Universal Windows Platform.", "Solution missing", MessageBoxButton.OK, MessageBoxImage.Error); return; } var uwpSolutionDirectory = Path.GetDirectoryName(uwpSolutionFileLocation); var projectName = GetProjectName(uwpSolutionFileLocation); var namespaceName = GetNamespaceName(projectName); var projectDirectory = Path.Combine(uwpSolutionDirectory, projectName); var displayName = gameDisplayNameTextBox.Text; var displayDescription = descriptionTextBox.Text; int startWidth; int startHeight; int minWidth; int minHeight; try { startWidth = int.Parse(widthTextBox.Text); startHeight = int.Parse(heightTextBox.Text); minWidth = int.Parse(minWidthTextBox.Text); minHeight = int.Parse(minHeightTextBox.Text); } catch (Exception) { MessageBox.Show("Invalid input for one of the size fields. Whole numbers only.", "Invalid input", MessageBoxButton.OK, MessageBoxImage.Error); return; } bool resizable = resizableCheckBox.IsChecked ?? false; try { AddGameBarPackage(uwpSolutionDirectory, projectName); } catch (Exception) { MessageBox.Show("An error occured when adding the Game Bar package.", "Failed", MessageBoxButton.OK, MessageBoxImage.Error); return; } try { ModifyAppManifest(uwpSolutionDirectory, projectName, true, displayName, displayDescription, startWidth, startHeight, minWidth, minHeight, resizable); } catch (Exception) { MessageBox.Show("An error occured when modifying the project's appxmanifest.", "Failed", MessageBoxButton.OK, MessageBoxImage.Error); return; } try { ModifyAppH(projectDirectory); } catch (Exception) { MessageBox.Show("An error occured when modifying the project's App.xaml.h file.", "Failed", MessageBoxButton.OK, MessageBoxImage.Error); return; } try { ModifyAppCpp(projectDirectory); } catch (Exception) { MessageBox.Show("An error occured when modifying the project's App.xaml.cpp file.", "Failed", MessageBoxButton.OK, MessageBoxImage.Error); return; } MessageBox.Show("Game Bar widget successfully attached to the Unity project.", "Success", MessageBoxButton.OK, MessageBoxImage.Information); }
public static HashSet <string> GetFiles( ResultCache cache, IEnumerable <string> searchablePaths, IEnumerable <IPattern> includePaths, IEnumerable <IPattern> excludePaths, string basePath = null) { searchablePaths = searchablePaths as string[] ?? searchablePaths.ToArray(); includePaths = includePaths as IPattern[] ?? includePaths.ToArray(); if (excludePaths != null) { excludePaths = excludePaths as IPattern[] ?? excludePaths.ToArray(); } else { excludePaths = new List <IPattern>(); } basePath = basePath ?? "./"; bool returnAbsolutePaths = Path.IsPathRooted(basePath); string absBasePath; if (basePath == "./" || basePath == ".") { absBasePath = new DirectoryInfo(Directory.GetCurrentDirectory()).FullName; } else { absBasePath = new DirectoryInfo(basePath).FullName; } (int hash, bool hasResults, HashSet <string> files)cacheRequest = cache?.GetResultsOrReserve( searchablePaths, includePaths, excludePaths, basePath) ?? (0, false, null); if (cacheRequest.hasResults) { Log.Debug("Getting files for query hash {{{0}}} from cached results for base path '{1}':", cacheRequest.hash, basePath); Log.IndentedCollection(cacheRequest.files, Log.Debug); return(cacheRequest.files); } Log.Debug("Getting files for query hash {{{0}}} using base path '{1}' and provided include/exclude paths:", cacheRequest.hash, basePath); using (new CompositeDisposable( new Log.ScopedIndent(), new Log.ScopedTimer(Log.Level.Debug, "GetFiles(...)", $"{{{cacheRequest.hash,-11}}} {basePath}"))) { Log.Debug("search paths:"); Log.IndentedCollection(searchablePaths, Log.Debug); HashSet <string> includeFiles; HashSet <GLOB> includeGlobs; HashSet <RegexPattern> includeRegexes; HashSet <string> excludeFiles; HashSet <GLOB> excludeGlobs; HashSet <RegexPattern> excludeRegexes; (includeFiles, includeGlobs, includeRegexes) = ProcessFileValues(includePaths); (excludeFiles, excludeGlobs, excludeRegexes) = ProcessFileValues(excludePaths); var searchPathMatches = new Dictionary <string, List <PatternMatch> >(); foreach (string currentSearchPath in searchablePaths) { var currentMatches = new List <PatternMatch>(); var dir = new DirectoryInfo(new DirectoryInfo( currentSearchPath == "./" || currentSearchPath == "." ? Directory.GetCurrentDirectory() : currentSearchPath) .FullName); bool makeCandidatesAbsolute = Path.IsPathRooted(currentSearchPath); if (!dir.Exists) { Log.Debug("Skipping searchable directory because it does not exist: {0}'", currentSearchPath); continue; } string[] candidates = dir.GetFilesSafeRecursive("*") .Select(f => GetPath(makeCandidatesAbsolute, f.FullName, absBasePath)) .Reverse() .ToArray(); DirectoryInfo[] allDirs = dir.GetDirectoriesSafeRecursive("*") .Reverse() .Concat(new[] { dir }) .ToArray(); #region includes if (includeGlobs != null && includeGlobs.Count > 0) { foreach (GLOB glob in includeGlobs) { IEnumerable <string> matchesForGlob = candidates.Where(f => glob.IsMatch(f)); currentMatches.AddRange(matchesForGlob.Select( f => new PatternMatch(f, currentSearchPath, "glob \"" + glob.Pattern + "\""))); } } if (includeRegexes != null && includeRegexes.Count > 0) { IEnumerable <PatternMatch> matchesForRegex = includeRegexes.SelectMany( r => r.FilterMatches(candidates).Select( f => new PatternMatch(f, currentSearchPath, r.ToString()))); currentMatches.AddRange(matchesForRegex); } var literalPatternMatches = new Dictionary <string, PatternMatch[]>(); if (includeFiles != null && includeFiles.Count > 0) { foreach (string filePattern in includeFiles.ToArray()) { string[] matchesForFile = (from dirInfo in allDirs select Path.Combine(dirInfo.FullName, filePattern) into includeFilePath where File.Exists(includeFilePath) select GetPath(makeCandidatesAbsolute, includeFilePath, absBasePath)) .ToArray(); PatternMatch[] patternMatchesForFile = matchesForFile.Select( f => new PatternMatch(f, currentSearchPath, filePattern)) .ToArray(); if (patternMatchesForFile.Length > 0) { literalPatternMatches[filePattern] = patternMatchesForFile; currentMatches.AddRange(patternMatchesForFile); } } } #endregion #region excludes IEnumerable <PatternMatch> tempMatches = currentMatches; if (excludeGlobs != null && excludeGlobs.Count > 0) { var excludeGlob = new CompositeGlob(excludeGlobs, null); tempMatches = tempMatches.Where(m => !excludeGlob.IsMatch(m.File)) .ToList(); // Helps with debugging } if (excludeRegexes != null && excludeRegexes.Count > 0) { tempMatches = tempMatches.Where(m => excludeRegexes.All(r => !r.Regex.IsMatch(m.File))) .ToList(); // Helps with debugging } if (excludeFiles != null && excludeFiles.Count > 0) { tempMatches = tempMatches.Where(m => excludeFiles.All(x => x != Path.GetFileName(m.File))) .ToList(); // Helps with debugging } #endregion #region literal validation currentMatches = tempMatches.ToList(); foreach (KeyValuePair <string, PatternMatch[]> kvp in literalPatternMatches) { PatternMatch[] patternMatchesForFile = kvp.Value; if (patternMatchesForFile.Length > 1 && currentMatches.Intersect(patternMatchesForFile).Count() > 1) { Log.Warn("The literal pattern '{0}' matched more than one file.", kvp.Key); Log.Warn("Only the first match '{0}' will be returned. See all matches below.", patternMatchesForFile.First().File); int count = 0; Log.IndentedCollection(patternMatchesForFile, p => $"{p.File} (from {p.SearchPath}) {(count++ == 0 ? "*" : "")}", Log.Warn); currentMatches = currentMatches.Except(patternMatchesForFile.Skip(1)).ToList(); } } searchPathMatches[currentSearchPath] = currentMatches; #endregion } #region validation IEnumerable <PatternMatch> allMatches = searchPathMatches.Values.SelectMany(v => v); IEnumerable <PatternMatch> finalMatches = ValidateMatches(allMatches, includePaths); #endregion #region results HashSet <string> allMatchedFiles = finalMatches.Select(m => GetPath(returnAbsolutePaths, m.File, absBasePath)).ToHashSet(); Log.Debug("include globs:"); Log.IndentedCollection(includeGlobs, s => s.Pattern, Log.Debug); Log.Debug("include regexes:"); Log.IndentedCollection(includeRegexes, r => r.Value, Log.Debug); Log.Debug("include literals:"); Log.IndentedCollection(includeFiles, Log.Debug); Log.Debug("exclude globs:"); Log.IndentedCollection(excludeGlobs, s => s.Pattern, Log.Debug); Log.Debug("exclude regexes:"); Log.IndentedCollection(excludeRegexes, r => r.Value, Log.Debug); Log.Debug("exclude literals:"); Log.IndentedCollection(excludeFiles, Log.Debug); Log.Debug("matched files:"); Log.IndentedCollection(allMatchedFiles, Log.Debug); cache?.CacheResults(allMatchedFiles, cacheRequest.hash); return(allMatchedFiles); #endregion } }
internal static bool IsPartiallyQualified(string path) { // This is much simpler than Windows where paths can be rooted, but not fully qualified (such as Drive Relative) // As long as the path is rooted in Unix it doesn't use the current directory and therefore is fully qualified. return(!Path.IsPathRooted(path)); }