private void SetActualVersionForSolution(Lifetime lt) { var projectVersionTxtPath = mySolutionDirectory.Combine("ProjectSettings/ProjectVersion.txt"); myFileSystemTracker.AdviseFileChanges(lt, projectVersionTxtPath, _ => { myVersionFromProjectVersionTxt = TryGetVersionFromProjectVersion(projectVersionTxtPath); UpdateActualVersionForSolution(); }); myVersionFromProjectVersionTxt = TryGetVersionFromProjectVersion(projectVersionTxtPath); var editorInstanceJsonPath = mySolutionDirectory.Combine("Library/EditorInstance.json"); myFileSystemTracker.AdviseFileChanges(lt, editorInstanceJsonPath, _ => { myVersionFromEditorInstanceJson = TryGetApplicationPathFromEditorInstanceJson(editorInstanceJsonPath); UpdateActualVersionForSolution(); }); myVersionFromEditorInstanceJson = TryGetApplicationPathFromEditorInstanceJson(editorInstanceJsonPath); UpdateActualVersionForSolution(); }
private PackageData GetEmbeddedPackage(string id, string filePath) { // Embedded packages live in the Packages folder. When reading from packages-lock.json, the filePath has a // 'file:' prefix. We make sure it's the folder name when there is no packages-lock.json var packageFolder = myPackagesFolder.Combine(filePath.TrimFromStart("file:")); return(GetPackageDataFromFolder(id, packageFolder, PackageSource.Embedded)); }
public new void SetUp() { _solutionPathProvider = new FixedSolutionPathProvider(TestDataPath2.Parent.Parent.Parent); _gitRepositoryProvider = new TestGitRepositoryProvider(); _gitDirectoryPath = TestDataPath2.Parent.Combine(_gitRepositoryProvider.GitDirectoryName); _gitDirectoryPath.CreateDirectory(); _gitDirectoryPath.Combine("config").WriteAllText("https://repository.url/"); _gitDirectoryPath.Combine("HEAD").WriteAllText("my_branch"); }
private PackageData GetPackageDataFromFolder([CanBeNull] string id, [NotNull] FileSystemPath packageFolder, PackageSource packageSource, [CanBeNull] GitDetails gitDetails = null, [CanBeNull] FileSystemPath tarballLocation = null) { if (packageFolder.ExistsDirectory) { var packageJsonFile = packageFolder.Combine("package.json"); if (packageJsonFile.ExistsFile) { try { var packageJson = PackageJson.FromJson(packageJsonFile.ReadAllText2().Text); var packageDetails = PackageDetails.FromPackageJson(packageJson, packageFolder); return(new PackageData(id ?? packageDetails.CanonicalName, packageFolder, packageJsonFile.FileModificationTimeUtc, packageDetails, packageSource, gitDetails, tarballLocation)); } catch (Exception e) { myLogger.LogExceptionSilently(e); return(null); } } } return(null); }
public void Initialise() { if (agentControl != null) { return; } var manifestLocation = agentLocation.Combine("DoubleAgent.sxs.manifest"); agentControl = ActivationContext.Using(manifestLocation.FullPath, () => new Control()); agentControl.AutoConnect = 0; agentControl.CharacterStyle = (int)(CharacterStyleFlags.IdleEnabled | CharacterStyleFlags.Smoothed | CharacterStyleFlags.SoundEffects); agentControl.CharacterFiles.SearchPath = agentLocation.FullPath; agentControl.Click += agentControl_Click; agentControl.Command += agentControl_Command; agentControl.DblClick += agentControl_DblClick; agentControl.DragStart += agentControl_DragStart; agentControl.DragComplete += agentControl_DragComplete; agentControl.Hide += agentControl_Hide; agentControl.Move += agentControl_Move; agentControl.RequestStart += agentControl_RequestStart; agentControl.RequestComplete += agentControl_RequestComplete; agentControl.Show += agentControl_Show; }
private bool CopyFiles(FileSystemPath pluginDir) { var updatedFileCount = 0; var existingPluginFiles = pluginDir.GetChildFiles(); foreach (var filename in ourPluginFiles) { var path = pluginDir.Combine(filename); if (existingPluginFiles.Contains(path)) { continue; } var resourceName = resourceNamespace + filename; using (var resourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName)) { if (resourceStream == null) { myLogger.LogMessage(LoggingLevel.ERROR, "Plugin file not found in manifest resources. " + filename); return(false); } using (var fileStream = path.OpenStream(FileMode.CreateNew)) { resourceStream.CopyTo(fileStream); updatedFileCount++; } } } return(updatedFileCount > 0); }
public static Version GetVersionByAppPath(FileSystemPath appPath) { if (appPath == null || appPath.Exists == FileSystemPath.Existence.Missing) { return(null); } Version version = null; ourLogger.CatchWarn(() => // RIDER-23674 { switch (PlatformUtil.RuntimePlatform) { case PlatformUtil.Platform.Windows: ourLogger.CatchWarn(() => { version = new Version( new Version(FileVersionInfo.GetVersionInfo(appPath.FullPath).FileVersion) .ToString(3)); }); var resource = new VersionResource(); resource.LoadFrom(appPath.FullPath); var unityVersionList = resource.Resources.Values.OfType <StringFileInfo>() .Where(c => c.Default.Strings.Keys.Any(b => b == "Unity Version")).ToArray(); if (unityVersionList.Any()) { var unityVersion = unityVersionList.First().Default.Strings["Unity Version"].StringValue; version = Parse(unityVersion); } break; case PlatformUtil.Platform.MacOsX: var infoPlistPath = appPath.Combine("Contents/Info.plist"); if (infoPlistPath.ExistsFile) { var docs = XDocument.Load(infoPlistPath.FullPath); var keyValuePairs = docs.Descendants("dict") .SelectMany(d => d.Elements("key").Zip(d.Elements().Where(e => e.Name != "key"), (k, v) => new { Key = k, Value = v })) .GroupBy(x => x.Key.Value) .Select(g => g.First()) // avoid exception An item with the same key has already been added. .ToDictionary(i => i.Key.Value, i => i.Value.Value); version = Parse(keyValuePairs["CFBundleVersion"]); } break; case PlatformUtil.Platform.Linux: version = Parse(appPath.FullPath); // parse from path break; } }); return(version); }
public PackageManager(Lifetime lifetime, ISolution solution, ILogger logger, UnitySolutionTracker unitySolutionTracker, UnityVersion unityVersion, IFileSystemTracker fileSystemTracker) { myLifetime = lifetime; mySolution = solution; myLogger = logger; myUnityVersion = unityVersion; myFileSystemTracker = fileSystemTracker; // Refresh the packages in the guarded context, safe from reentrancy. myGroupingEvent = solution.Locks.GroupingEvents.CreateEvent(lifetime, "Unity::PackageManager", TimeSpan.FromMilliseconds(500), Rgc.Guarded, DoRefresh); myPackagesById = new DictionaryEvents <string, PackageData>(lifetime, "Unity::PackageManager"); myPackageLifetimes = new Dictionary <string, LifetimeDefinition>(); myPackagesFolder = mySolution.SolutionDirectory.Combine("Packages"); myPackagesLockPath = myPackagesFolder.Combine("packages-lock.json"); myManifestPath = myPackagesFolder.Combine("manifest.json"); unitySolutionTracker.IsUnityProject.AdviseUntil(lifetime, value => { if (!value) { return(false); } ScheduleRefresh(); // Track changes to manifest.json and packages-lock.json. Also track changes in the Packages folder, but // only top level, not recursively. We only want to update the packages if a new package has been added // or removed var packagesFolder = mySolution.SolutionDirectory.Combine("Packages"); fileSystemTracker.AdviseFileChanges(lifetime, packagesFolder.Combine("packages-lock.json"), _ => ScheduleRefresh()); fileSystemTracker.AdviseFileChanges(lifetime, packagesFolder.Combine("manifest.json"), _ => ScheduleRefresh()); fileSystemTracker.AdviseDirectoryChanges(lifetime, packagesFolder, false, _ => ScheduleRefresh()); // We're all set up, terminate the advise return(true); }); }
public void Combine_Multipart_Multipart() { var path1 = FileSystemPath.Parse(@"a\b"); var path2 = FileSystemPath.Parse(@"c\d"); var result = FileSystemPath.Combine(path1, path2); var expected = FileSystemPath.Parse(@"a\b\c\d"); Assert.AreEqual(expected, result); }
public TestAdapterLoader GetTestAdapterLoader(ITestRunnerContext context) { var framework = context.RuntimeEnvironment.TargetFrameworkId.IsNetCoreSdk() ? "netstandard20" : "net461"; var adapters = Root.Combine($"{Namespace}.Adapters.{framework}.dll"); var tasks = Root.Combine($"{Namespace}.Tasks.{framework}.dll"); var type = TypeInfoFactory.Create($"{Namespace}.Adapters.MspecRunner", adapters.FullPath); return(new TestAdapterInfo(type, type) { AdditionalAssemblies = new[] { tasks.FullPath } }); }
private ProcessStartInfo GetCoreProcessStartInfo(int port, FileSystemPath basePath) { var sdkMajorVersion = myNuGetVersion.Major < 3 ? 3 : myNuGetVersion.Major; var runtimeConfigPath = basePath.Combine(ProtocolConstants.CoreRuntimeConfigFilename(sdkMajorVersion)); var fileSystemPath = basePath.Combine(ProtocolConstants.TypeProvidersHostCoreFilename); var dotnetArgs = $"--runtimeconfig \"{runtimeConfigPath}\""; Assertion.Assert(fileSystemPath.ExistsFile, $"can't find '{fileSystemPath.FullPath}'"); Assertion.Assert(runtimeConfigPath.ExistsFile, $"can't find '{runtimeConfigPath.FullPath}'"); var processStartInfo = new ProcessStartInfo { Arguments = $"{dotnetArgs} \"{fileSystemPath.FullPath}\" {port} \"{ProtocolConstants.LogFolder.Combine($"{DateTime.UtcNow:yyyy_MM_dd_HH_mm_ss_ffff}.log")}\"", FileName = "exec" }; return(processStartInfo); }
private static FileSystemPath GetCustomHubInstallPath(FileSystemPath appData) { var filePath = appData.Combine("UnityHub/secondaryInstallPath.json"); if (filePath.ExistsFile) { var text = filePath.ReadAllText2().Text.TrimStart('"').TrimEnd('"'); var customHubLocation = FileSystemPath.Parse(text); if (customHubLocation.ExistsDirectory) { return(customHubLocation); } } return(FileSystemPath.Empty); }
public static FileSystemPath GetAreaFolder([CanBeNull] IProject project, [CanBeNull] string area) { if (project == null) { return(FileSystemPath.Empty); } FileSystemPath basePath = project.Location; // Empty area ("") is the same as no area (null) if (!area.IsEmpty()) { basePath = basePath.Combine(AreasFolder).Combine(area); } return(basePath); }
private static ProcessStartInfo GetFrameworkProcessStartInfo(int port, FileSystemPath basePath) { var fileSystemPath = basePath.Combine(ProtocolConstants.TypeProvidersHostFrameworkFilename); Assertion.Assert(fileSystemPath.ExistsFile, $"can't find '{fileSystemPath.FullPath}'"); var processStartInfo = new ProcessStartInfo { Arguments = $"{port} \"{ProtocolConstants.LogFolder.Combine($"{DateTime.UtcNow:yyyy_MM_dd_HH_mm_ss_ffff}.log")}\"", FileName = fileSystemPath.FullPath }; return(processStartInfo); }
private FileSystemPath FindGitDirectory(FileSystemPath directory) { do { var gitDirectory = directory.Combine(GitDirectoryName); // IDEA: Add support for ".git"-file redirect if (gitDirectory.ExistsDirectory) { return(gitDirectory); } directory = directory.Parent; } while (!directory.IsEmpty); return(null); }
public static FileSystemPath GetApplicationContentsPath(FileSystemPath applicationPath) { if (applicationPath.IsEmpty) { return(applicationPath); } AssertApplicationPath(applicationPath); switch (PlatformUtil.RuntimePlatform) { case PlatformUtil.Platform.MacOsX: return(applicationPath.Combine("Contents")); case PlatformUtil.Platform.Linux: case PlatformUtil.Platform.Windows: return(applicationPath.Directory.Combine("Data")); } ourLogger.Error("Unknown runtime platform"); return(FileSystemPath.Empty); }
private PackageData GetBuiltInPackage(string id, string version, FileSystemPath builtInPackagesFolder) { // If we can identify the module root of the current project, use it to look up the module if (builtInPackagesFolder.ExistsDirectory) { var packageFolder = builtInPackagesFolder.Combine(id); return(GetPackageDataFromFolder(id, packageFolder, PackageSource.BuiltIn)); } // We can't find the actual package. If we "know" it's a module/built in package, then mark it as an // unresolved built in package, rather than just an unresolved package. The Unity Explorer can use this to // put the unresolved package in the right place, rather than show as a top level unresolved package simply // because we haven't found the application package cache yet. // We can rely on an ID starting with "com.unity.modules." as this is the convention Unity uses. Since they // control the namespace of their own registries, we can be confident that they won't publish normal // packages with the same naming convention. We can't be sure for third part registries, but if anyone does // that, they only have themselves to blame. // If we don't recognise the package as a built in, let someone else handle it return(id.StartsWith("com.unity.modules.") ? PackageData.CreateUnknown(id, version, PackageSource.BuiltIn) : null); }
private void SyncFromCloud(FileSystemPath localPath) { var remotePath = myRootFolder.Combine(localPath.Name).FullPath.Replace('\\', '/'); myClient.GetFileAsync(remotePath, response => { if (response.StatusCode == HttpStatusCode.OK) { localPath.WriteAllBytes(response.RawBytes); } }, exception => { if ((exception is DropboxRestException) && (((DropboxRestException)exception).StatusCode == HttpStatusCode.NotFound)) { myClient.UploadFileAsync(myRootFolder.FullPath.Replace('\\', '/'), new FileInfo(localPath.FullPath), data => { }, myClient.LogException); return; } myClient.LogException(exception); }); }
private FileSystemPath GetChunkFilePath(Vector3I chunkOffset) { return(FileSystemPath.Combine(worldDataPathRoot, FileSystemPath.CombineFileName(chunkOffset.ToString(), ChunkFileExtension))); }
private string GetRemotePath(FileSystemPath localPath) { return(myRootFolder.Combine(localPath.Name).FullPath.Replace('\\', '/')); }
public GameWorld(GameWorldConfiguration configuration, FileSystemPath worldFilePath, TrippingCubesGame game) { DateTime startTime = DateTime.Now; Game = game; Entities = new ReadOnlyCollection <IEntity>(entities); Physics = new PhysicsSystem(IsBlockSolid, IsBlockLiquid); Paths = new ReadOnlyDictionary <string, PathLinear>( configuration.Paths ?? new Dictionary <string, PathLinear>()); Log.Trace("Initializing world style..."); try { Game.Resources.LoadMesh(MeshData.Skybox).Subscribe( r => skyboxMesh = r); Game.Resources.LoadTexture(configuration.SkyboxPath, TextureFilter.Linear).Subscribe( r => skyboxTexture = r); if (!configuration.InnerSkyboxPath.IsEmpty) { Game.Resources.LoadTexture(configuration.InnerSkyboxPath, TextureFilter.Linear).Subscribe( r => innerSkyboxTexture = r); } } catch (Exception exc) { Log.Warning("The skybox couldn't be loaded and will not " + "be available.", exc); } try { DateTime localStartTime = DateTime.Now; BlockRegistryBuilder blockRegistryBuilder = BlockRegistryBuilder.FromXml( configuration.BlockRegistryPath, FileSystem, false); Blocks = blockRegistryBuilder.GenerateRegistry( FileSystem); Log.Trace("Block registry with " + Blocks.Count + " block definitions initialized in " + (DateTime.Now - localStartTime).TotalMilliseconds + "ms."); } catch (Exception exc) { throw new Exception("The block registry couldn't be " + "initialized.", exc); } Log.Trace("Initializing world chunk manager..."); try { FileSystemPath primaryWorldBackupPath = FileSystemPath.Combine(worldFilePath.GetParentDirectory(), $"{worldFilePath.GetFileName(false)}1"); FileSystemPath secondaryWorldBackupPath = FileSystemPath.Combine(worldFilePath.GetParentDirectory(), $"{worldFilePath.GetFileName(false)}2"); if (FileSystem.IsWritable) { try { if (FileSystem.ExistsFile(primaryWorldBackupPath)) { using Stream secondaryBackupStream = FileSystem.CreateFile(secondaryWorldBackupPath, true); using Stream primaryWorldBackup = FileSystem.OpenFile(primaryWorldBackupPath, false); primaryWorldBackup.CopyTo(secondaryBackupStream); } if (FileSystem.ExistsFile(worldFilePath)) { using Stream primaryWorldBackup = FileSystem.CreateFile(primaryWorldBackupPath, true); using Stream worldFile = FileSystem.OpenFile(worldFilePath, false); worldFile.CopyTo(primaryWorldBackup); } } catch (Exception exc) { throw new Exception("The world backups couldn't be " + "updated.", exc); } } if (FileSystem.ExistsFile(worldFilePath)) { zipFileSystem = new ZipFileSystem(FileSystem.OpenFile( worldFilePath, FileSystem.IsWritable)); } else if (FileSystem.IsWritable) { Log.Information("No world data file was found at the " + "specified path. A new world file is initialized."); zipFileSystem = ZipFileSystem.Initialize(FileSystem, worldFilePath, false); } else { throw new Exception("The world data file doesn't exist " + $"under the path {worldFilePath} and can't be created, " + "as the file system is read-only."); } RootChunk = new Chunk <BlockVoxel>( new BlockChunkManager(Blocks, Game.Resources, zipFileSystem, "/")); } catch (Exception exc) { throw new Exception("The world chunk manager couldn't be " + "initialized.", exc); } Log.Trace("Spawning entities..."); foreach (EntityInstantiation instantiation in configuration.Entities) { if (configuration.EntityConfigurations.TryGetValue( instantiation.ConfigurationIdentifier, out EntityConfiguration entityConfiguration)) { try { IEntity entity = entityConfiguration.Instantiate(this, instantiation.InstanceParameters); entities.Add(entity); } catch (Exception exc) { Log.Warning($"Entity #{entities.Count} couldn't " + "be spawned and will be skipped.", exc); } } } Log.Trace($"Spawned {entities.Count} entities."); Log.Trace("Game world initialized in " + (DateTime.Now - startTime).TotalMilliseconds + "ms."); }
public static string GetAngularJsVersion(FileSystemPath root, Version version) { return(root.Combine("angular." + version.ToString(3) + ".js").FullPath); }
public static ISymbolTable GetReferenceSymbolTable(IPathReference pathReference, bool useReferenceName, bool includeHttpHandlers = true) { var propertiesSearcher = pathReference.GetTreeNode().GetSolution().GetComponent<MSBuildPropertiesCache>(); string productHomeDir = propertiesSearcher.GetProjectPropertyByName(pathReference.GetTreeNode().GetProject(), "ProductHomeDir"); var basePath = new FileSystemPath(productHomeDir); if (basePath.IsEmpty) { return EmptySymbolTable.INSTANCE; } FolderQualifierInfo folderQualifierInfo = null; IPsiServices psiServices = pathReference.GetTreeNode().GetPsiServices(); var baseProjectFolder = psiServices.Solution.FindProjectItemsByLocation(basePath).FirstOrDefault() as IProjectFolder; if (baseProjectFolder != null) { folderQualifierInfo = new FolderQualifierInfo(baseProjectFolder); } FileSystemPath websiteRoot = GetRootPath(pathReference); IQualifier qualifier = pathReference.GetQualifier(); if (useReferenceName) { PathDeclaredElement target = null; string name = pathReference.GetName(); switch (name) { case PathDeclaredElement.CURRENT_DIR_NAME: target = new PathDeclaredElement(PathDeclaredElement.CURRENT_DIR_NAME, psiServices, basePath); break; case PathDeclaredElement.LEVEL_UP_NAME: target = new PathDeclaredElement(PathDeclaredElement.LEVEL_UP_NAME, psiServices, basePath.Directory); break; case PathDeclaredElement.ROOT_NAME: if (qualifier != null) { goto default; } target = new PathDeclaredElement(PathDeclaredElement.ROOT_NAME, psiServices, websiteRoot); break; default: try { string parserGenOutputBase = propertiesSearcher.GetProjectPropertyByName(pathReference.GetTreeNode().GetProject(), "ParserGenOutputBase"); FileSystemPath path = basePath.Combine(parserGenOutputBase + "\\" + name); target = new PathDeclaredElement(name, psiServices, path); } catch (InvalidPathException) { } catch (ArgumentException) { } break; } var table = new SymbolTable(psiServices, folderQualifierInfo != null ? new SymbolTableDependencySet(folderQualifierInfo) : null); if (target != null) { table.AddSymbol(target, EmptySubstitution.INSTANCE, 1); } return table; } FileSystemPath rootPath = (qualifier == null) ? websiteRoot : FileSystemPath.Empty; ISymbolTable symbolTableByPath = PathReferenceUtil.GetSymbolTableByPath(basePath, psiServices, basePath.Directory, rootPath, true); FileSystemPath basePathBeforeMapping = GetBasePathBeforeMapping(pathReference); if (!basePathBeforeMapping.IsNullOrEmpty()) { IWebProjectPathMapping pathMapping = WebPathMappingManager.GetPathMapping(pathReference); List<FileSystemPath> mappedPaths = pathMapping.GetAllPathPartsIn(basePathBeforeMapping).ToList(); if (mappedPaths.Any()) { var mappedPathsTable = new SymbolTable(psiServices, folderQualifierInfo != null ? new SymbolTableDependencySet(folderQualifierInfo) : null); foreach (FileSystemPath mappedPath in mappedPaths) { var declaredElement = new PathDeclaredElement(psiServices, mappedPath); mappedPathsTable.AddSymbol(declaredElement, EmptySubstitution.INSTANCE, 1); } symbolTableByPath = symbolTableByPath.Merge(mappedPathsTable); } } if (!includeHttpHandlers) { return symbolTableByPath; } var httpHandlersTable = new SymbolTable(psiServices); return httpHandlersTable.Merge(symbolTableByPath); }
public static ISymbolTable GetReferenceSymbolTable(IPathReference pathReference, bool useReferenceName, bool includeHttpHandlers = true) { var propertiesSearcher = pathReference.GetTreeNode().GetSolution().GetComponent <MSBuildPropertiesCache>(); string productHomeDir = propertiesSearcher.GetProjectPropertyByName(pathReference.GetTreeNode().GetProject(), "ProductHomeDir"); var basePath = new FileSystemPath(productHomeDir); if (basePath.IsEmpty) { return(EmptySymbolTable.INSTANCE); } FolderQualifierInfo folderQualifierInfo = null; IPsiServices psiServices = pathReference.GetTreeNode().GetPsiServices(); var baseProjectFolder = psiServices.Solution.FindProjectItemsByLocation(basePath).FirstOrDefault() as IProjectFolder; if (baseProjectFolder != null) { folderQualifierInfo = new FolderQualifierInfo(baseProjectFolder); } FileSystemPath websiteRoot = GetRootPath(pathReference); IQualifier qualifier = pathReference.GetQualifier(); if (useReferenceName) { PathDeclaredElement target = null; string name = pathReference.GetName(); switch (name) { case PathDeclaredElement.CURRENT_DIR_NAME: target = new PathDeclaredElement(PathDeclaredElement.CURRENT_DIR_NAME, psiServices, basePath); break; case PathDeclaredElement.LEVEL_UP_NAME: target = new PathDeclaredElement(PathDeclaredElement.LEVEL_UP_NAME, psiServices, basePath.Directory); break; case PathDeclaredElement.ROOT_NAME: if (qualifier != null) { goto default; } target = new PathDeclaredElement(PathDeclaredElement.ROOT_NAME, psiServices, websiteRoot); break; default: try { string parserGenOutputBase = propertiesSearcher.GetProjectPropertyByName(pathReference.GetTreeNode().GetProject(), "ParserGenOutputBase"); FileSystemPath path = basePath.Combine(parserGenOutputBase + "\\" + name); target = new PathDeclaredElement(name, psiServices, path); } catch (InvalidPathException) { } catch (ArgumentException) { } break; } var table = new SymbolTable(psiServices, folderQualifierInfo != null ? new SymbolTableDependencySet(folderQualifierInfo) : null); if (target != null) { table.AddSymbol(target, EmptySubstitution.INSTANCE, 1); } return(table); } FileSystemPath rootPath = (qualifier == null) ? websiteRoot : FileSystemPath.Empty; ISymbolTable symbolTableByPath = PathReferenceUtil.GetSymbolTableByPath(basePath, psiServices, basePath.Directory, rootPath, true); FileSystemPath basePathBeforeMapping = GetBasePathBeforeMapping(pathReference); if (!basePathBeforeMapping.IsNullOrEmpty()) { IWebProjectPathMapping pathMapping = WebPathMappingManager.GetPathMapping(pathReference); List <FileSystemPath> mappedPaths = pathMapping.GetAllPathPartsIn(basePathBeforeMapping).ToList(); if (mappedPaths.Any()) { var mappedPathsTable = new SymbolTable(psiServices, folderQualifierInfo != null ? new SymbolTableDependencySet(folderQualifierInfo) : null); foreach (FileSystemPath mappedPath in mappedPaths) { var declaredElement = new PathDeclaredElement(psiServices, mappedPath); mappedPathsTable.AddSymbol(declaredElement, EmptySubstitution.INSTANCE, 1); } symbolTableByPath = symbolTableByPath.Merge(mappedPathsTable); } } if (!includeHttpHandlers) { return(symbolTableByPath); } var httpHandlersTable = new SymbolTable(psiServices); return(httpHandlersTable.Merge(symbolTableByPath)); }
public void Default() { _gitDirectory.Combine("HEAD").WriteAllText("ref: refs/heads/my_branch"); DoNamedTest(); }
public static string GetAngularJsVersion(FileSystemPath root, Version version) { return root.Combine("angular." + version.ToString(3) + ".js").FullPath; }