public void AssertUX(string code, [CallerMemberName] string path = "") { int caret = 0; var assertCodeSnippets = GetAsserts(ref code, ref caret); var filePath = AbsoluteDirectoryPath.Parse(Directory.GetCurrentDirectory()) / new FileName(path); var log = new DummyLogger(); var context = Context.CreateContext(filePath, code, caret, new DummySourcePackage()); var mainPackage = PackageCache.GetPackage(new Log(log.TextWriter), _project); mainPackage.SetCacheDirectory((AbsoluteDirectoryPath.Parse(mainPackage.CacheDirectory) / new DirectoryName("UxCompletion")).NativePath); var build = new CodeNinjaBuild(log, _project, _editors, mainPackage, mainPackage.References.ToList(), code, filePath); build.Execute(); var suggestions = SuggestionParser.GetSuggestions(build.Compiler, context, caret, new DummyReader()); if (assertCodeSnippets != null) { foreach (var codeSnippet in assertCodeSnippets) { OnAssert(code, codeSnippet, suggestions, log); } } }
public static IEnumerable <AbsoluteDirectoryPath> LookForPathInUninstall(string partOfName) { var registryKey = @"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall"; var key = Registry.LocalMachine.OpenSubKey(registryKey); if (key != null) { foreach (var subkey in key.GetSubKeyNames().Select(keyName => key.OpenSubKey(keyName))) { var displayName = subkey.GetValue("DisplayName") as string; if (displayName != null && displayName.Contains(partOfName)) { var installLocation = subkey.GetValue("InstallLocation") as string; yield return(AbsoluteDirectoryPath.Parse(installLocation)); } } key.Close(); } registryKey = @"SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall"; key = Registry.LocalMachine.OpenSubKey(registryKey); if (key != null) { foreach (var subkey in key.GetSubKeyNames().Select(keyName => key.OpenSubKey(keyName))) { var displayName = subkey.GetValue("DisplayName") as string; if (displayName != null && displayName.Contains(partOfName)) { var installLocation = subkey.GetValue("InstallLocation") as string; yield return(AbsoluteDirectoryPath.Parse(installLocation)); } } key.Close(); } }
protected void TestPerformance(string code, [CallerMemberName] string testName = "") { ConfigureProjectReferences(); //get calling method info StackTrace stackTrace = new StackTrace(); var callingMethod = stackTrace.GetFrame(1).GetMethod(); var testAttribute = (PerformanceTestAttribute)callingMethod.GetCustomAttributes(typeof(PerformanceTestAttribute), true)[0]; var caret = GetCaret(ref code); var filePath = AbsoluteDirectoryPath.Parse(Directory.GetCurrentDirectory()) / new FileName(testName); var log = new DummyLogger(); var context = Context.CreateContext(filePath, code, caret, new DummySourcePackage()); var mainPackage = PackageCache.GetPackage(new Log(log.TextWriter), _project); mainPackage.SetCacheDirectory((AbsoluteDirectoryPath.Parse(mainPackage.CacheDirectory) / new DirectoryName("UxCompletion")).NativePath); var build = new CodeNinjaBuild(log, _project, _editors, mainPackage, mainPackage.References.ToList(), code, filePath); build.Execute(); Stopwatch sw = new Stopwatch(); sw.Start(); SuggestionParser.GetSuggestions(build.Compiler, context, caret, new DummyReader()); sw.Stop(); if (_context == null) { throw new ArgumentNullException("_context"); } _context.Logger.LogTimeEvent(testName, testAttribute.Description, sw.ElapsedMilliseconds / 1000f); }
public IAbsolutePath ResolveAbsolutePath(string nativePath) { try { var absPath = Path.IsPathRooted(nativePath) ? nativePath : Path.GetFullPath(nativePath); var isDirectory = Directory.Exists(nativePath); return(isDirectory ? (IAbsolutePath)AbsoluteDirectoryPath.Parse(absPath) : (IAbsolutePath)AbsoluteFilePath.Parse(absPath)); } catch (ArgumentException e) { throw new InvalidPath(nativePath, e); } catch (NotSupportedException e) { throw new InvalidPath(nativePath, e); } catch (PathTooLongException e) { throw new InvalidPath(nativePath, e); } }
public void SketchListFilePath_OnlyReplacesAtEnd() { var stupidProjectRoot = AbsoluteDirectoryPath.Parse(Platform.OperatingSystem == OS.Windows ? @"c:\Project.unoproj" : "/Project.unoproj"); var projectFilePath = stupidProjectRoot / new FileName("Project.unoproj"); var sketchPath = SketchImportUtils.SketchListFilePath(projectFilePath); Assert.That(sketchPath, Is.EqualTo(stupidProjectRoot / new FileName("Project.sketchFiles"))); }
public void ParseAndMakeAbsolute_AbsoluteWithRoot() { var root = Platform.OperatingSystem == OS.Windows ? @"C:\root" : "/root"; var foo = Platform.OperatingSystem == OS.Windows ? @"C:\foo" : "/foo"; Assert.That( FilePath.ParseAndMakeAbsolute(foo, AbsoluteDirectoryPath.Parse(root)), Is.EqualTo(AbsoluteFilePath.Parse(foo))); }
public void ParseAndMakeAbsolute_RelativeWithRoot() { var root = Platform.OperatingSystem == OS.Windows ? @"C:\root" : "/root"; var rootPath = AbsoluteDirectoryPath.Parse(root); Assert.That( FilePath.ParseAndMakeAbsolute("foo", rootPath), Is.EqualTo(rootPath / new FileName("foo"))); }
public IEnumerable <AbsoluteDirectoryPath> GetApplications(string identifier) { var appUrls = LaunchServices.GetApplicationUrlsForBundleIdentifier(new NSString(identifier)); if (appUrls == null) { return(Enumerable.Empty <AbsoluteDirectoryPath>()); } return(appUrls.Select(p => AbsoluteDirectoryPath.Parse(p.Path))); }
static TestBase() { var unoprojfile = AbsoluteDirectoryPath.Parse(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)) / ".." / ".." / ".." / "Outracks.CodeCompletion.UXNinja.TestsCommon" / "TestData" / new FileName("Outracks.UXNinja.Tests.Library.unoproj"); var relativeUnoprojFile = unoprojfile.RelativeTo(DirectoryPath.GetCurrentDirectory()); _editors = new DummyEditorManager(); _project = new Project("Test"); _project.MutablePackageReferences.Clear(); _project.MutableProjectReferences.Clear(); _project.MutableProjectReferences.Add(new ProjectReference(new DummySource(), relativeUnoprojFile.NativeRelativePath)); }
/// <exception cref="Exception"></exception> /// <exception cref="FailedToCreateOutputDir"></exception> public SimulatorUnoProject CreateSimulatorProject(BuildProject args, PreviewTarget target, bool directToDevice, bool quitAfterApkLaunch) { var project = AbsoluteFilePath.Parse(args.ProjectPath); var buildProject = Project.Load(project.NativePath); var projectDir = project.ContainingDirectory; var basePath = AbsoluteDirectoryPath.Parse(buildProject.BuildDirectory) / target.ToString(); var outputDir = FindOutputDir(args, basePath); var preambleDir = outputDir / "preamble"; var cacheDir = outputDir / "cache"; _cacheCleaner.CleanIfNecessary(cacheDir); SetCacheDir(buildProject, projectDir, cacheDir); var applicationClassName = TypeName.Parse("Outracks.Simulator.GeneratedApplication"); var applicationClass = ApplicationClassGenerator.CreateApplicationClass(args, buildProject.Name, applicationClassName); var dependencies = ApplicationClassGenerator.Dependencies; AddPreamble(buildProject, preambleDir, projectDir, applicationClass, dependencies); AddIcons(buildProject, preambleDir, projectDir); ChangePackageName(buildProject); ChangeTitle(buildProject, oldTitle => oldTitle + " (preview)"); var buildOptions = new BuildOptions { OutputDirectory = outputDir.NativePath, Configuration = BuildConfiguration.Preview, MainClass = applicationClassName.FullName, Strip = target != PreviewTarget.Local, }; foreach (var define in args.Defines.UnionOne("Designer")) { buildOptions.Defines.Add(define); } if (target == PreviewTarget.iOS && !directToDevice) { // 17.12.15 - Prevent double building when exporting to iOS. (Uno bug) buildOptions.RunArguments = "debug"; buildOptions.Native = false; } if (quitAfterApkLaunch) { buildOptions.RunArguments += " -L"; } return(new SimulatorUnoProject(buildProject, buildOptions, "", args.Verbose, args.BuildLibraries)); }
AbsoluteDirectoryPath FindOutputDir(BuildProject args, AbsoluteDirectoryPath basePath) { if (string.IsNullOrWhiteSpace(args.OutputDir)) { var outputDirWithLock = _outputDirGenerator.CreateOrReuseOutputDir(_isHost ? basePath / "PreviewHost" : basePath / "Preview"); _registerLock(outputDirWithLock.LockFile); return(outputDirWithLock.OutputDir); } else { return(AbsoluteDirectoryPath.Parse(args.OutputDir)); } }
static void AssertIfDiffers(MessageDatabase database, string filePathStr) { #if DUMP_MODE var relativePath = RelativeFilePath.Parse(filePathStr); var dumpPath = AbsoluteDirectoryPath.Parse("../../") / relativePath; database.Dump(dumpPath); #endif var filePath = AbsoluteFilePath.Parse(filePathStr); var originalDatabase = MessageDatabase.From(filePath); MessageDatabase.From(filePath); var errors = new Subject <string>(); errors.Subscribe(Console.WriteLine); Assert.True(MessageDatabase.IsEqualWhileIgnoreComments(originalDatabase, database, errors), "Looks like you have changed the plugin API"); }
bool ChangeProject(string projectPath) { _currentProject = Project.Load(projectPath); new Shell() .Watch(AbsoluteFilePath.Parse(projectPath).ContainingDirectory, "*.unoproj") .Where(e => e.Event == FileSystemEvent.Changed || e.Event == FileSystemEvent.Removed) .Subscribe(f => _currentProject = null); MainPackage = PackageCache.GetPackage(Log.Default, _currentProject); MainPackage.SetCacheDirectory((AbsoluteDirectoryPath.Parse(MainPackage.CacheDirectory) / new DirectoryName("CodeCompletion")).NativePath); TriggerBuild(); return(true); }
public IEnumerable <AbsoluteDirectoryPath> GetPathToApplicationsThatContains(string name) { foreach (var app in GetApplications(name)) { yield return(app); } var directories = Directory.GetDirectories("/Applications"); foreach (var directory in directories) { if (directory.Contains(name)) { yield return(AbsoluteDirectoryPath.Parse(directory)); } } }
public static AbsoluteFilePath GetSystemGuidPath() { if (Platform.OperatingSystem == OS.Windows) { return(AbsoluteDirectoryPath.Parse( Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData)) / "Fusetools" / "Fuse" / new FileName(".user")); } else if (Platform.OperatingSystem == OS.Mac) { return(AbsoluteDirectoryPath.Parse( Environment.GetFolderPath(Environment.SpecialFolder.Personal)) / ".fuse" / new FileName(".user")); } throw new PlatformNotSupportedException("Not implemented on platform: " + Platform.OperatingSystem); }
static void CopyAllFilesRecursive(AbsoluteDirectoryPath dir, AbsoluteDirectoryPath outDir) { var files = Directory.GetFiles(dir.NativePath); foreach (var file in files) { File.Copy(file, (outDir / Path.GetFileName(file)).NativePath, true); } var childrenDirs = Directory.GetDirectories(dir.NativePath); foreach (var childrenDir in childrenDirs) { var childrenOutDir = outDir / new DirectoryName(Path.GetFileName(childrenDir)); Create(childrenOutDir); CopyAllFilesRecursive(AbsoluteDirectoryPath.Parse(childrenDir), childrenOutDir); } }
public static void Shoot(string name) { try { var shell = new Shell(); var dir = AbsoluteDirectoryPath.Parse(Environment.CurrentDirectory).Combine("diagnostics"); shell.Create(dir); var file = dir.Combine(new FileName(name)); // Not taking screenshots on other platforms than Mac right now, // The preview tests running on Windows is not that unstable, so not currently important to do that. if (Platform.OperatingSystem != OS.Mac) { return; } var psi = new ProcessStartInfo("screencapture", "\"" + file.NativePath + "\"") { UseShellExecute = false, CreateNoWindow = true }; var p = Process.Start(psi); if (p == null) { throw new InvalidOperationException("Unable to start screencapture process"); } if (!p.WaitForExit(5000)) { p.Kill(); throw new InvalidOperationException("Timeout while trying to take screenshot"); } if (p.ExitCode != 0) { throw new InvalidOperationException("Got exit code " + p.ExitCode + " while trying to take screenshot"); } } catch (Exception e) { Console.WriteLine("Unable to take screenshot, because: " + e); } }
public IEnumerable <AbsoluteDirectoryPath> GetJdkSearchPaths(IFileSystem fs) { var defaultInstallLocations = Enumerable.Empty <AbsoluteDirectoryPath>(); if (Platform.OperatingSystem == OS.Windows) { var defaultSearchLocation = PathExtensions.GetEnvironmentPath(Environment.SpecialFolder.ProgramFiles) / new DirectoryName("Java"); if (fs.Exists(defaultSearchLocation)) { defaultInstallLocations = fs.GetDirectories(defaultSearchLocation, "jdk*").Reverse(); } return(defaultInstallLocations); } else if (Platform.OperatingSystem == OS.Mac) { var javaHome = Environment .GetEnvironmentVariable("JAVA_HOME") .ToOptional() .SelectMany(AbsoluteDirectoryPath.TryParse); var defaultSearchLocation = AbsoluteDirectoryPath.Parse("/Library/Java/JavaVirtualMachines"); if (fs.Exists(defaultSearchLocation)) { var jdkBaseDirectories = fs.GetDirectories(defaultSearchLocation, "jdk*").Reverse(); defaultInstallLocations = jdkBaseDirectories.Select( dir => dir / new DirectoryName("Contents") / new DirectoryName("Home")); } return(new[] { javaHome, } .NotNone() .Concat(defaultInstallLocations)); } throw new PlatformNotSupportedException(); }
public CodeNinjaBuild(ILog logWriter, Project project, IEditorManager editors, SourcePackage mainPackage, List <SourcePackage> referencedPackages, string extraCode = null, AbsoluteFilePath extraSourcePath = null) { _log = new Log(logWriter.TextWriter); _log.MaxErrorCount = 0; _logWriter = logWriter; _editors = editors; //var newPackages = new List<SourcePackage>(); //mainPackage = Uno.Build.Packages.PackageResolver.ResolvePackages(_log, project, newPackages); AddNotAddedPackages(referencedPackages); mainPackage.References.Clear(); _packages.Each(p => mainPackage.References.Add(p)); ProjectPackage = mainPackage; _extraCode = extraCode; _extraCodeSource = extraSourcePath; var configuration = new CodeNinjaBuildTarget(); var backend = configuration.CreateBackend(); var projectDir = project.RootDirectory; var rootDir = AbsoluteDirectoryPath.Parse(Path.Combine(projectDir, ".CodeNinja")); _compiler = new Compiler( _log, backend, ProjectPackage, new CompilerOptions { Debug = true, CodeCompletionMode = true, OutputDirectory = (rootDir / "Output").ToString(), BuildTarget = new DefaultBuild().Identifier, Strip = false }); _projDir = AbsoluteDirectoryPath.Parse(ProjectPackage.SourceDirectory); _filePaths = project.SourceFiles.Select(x => x.UnixPath).Select(RelativeFilePath.Parse).ToList(); }
protected void AssertCode(string code, [CallerMemberName] string path = "") { int caret = 0; var assertCodeSnippets = GetAsserts(ref code, ref caret); var ubProject = _project; var filePath = AbsoluteDirectoryPath.Parse(Directory.GetCurrentDirectory()) / new FileName(path); _log = new DummyLogger(); var editors = new DummyEditorManager(); var mainPackage = new PackageCache(new Log(_log.TextWriter), ubProject.Config).GetPackage(ubProject); mainPackage.SetCacheDirectory((AbsoluteDirectoryPath.Parse(mainPackage.CacheDirectory) / new DirectoryName("CodeCompletion")).NativePath); var build = new CodeNinjaBuild(_log, ubProject, editors, mainPackage, mainPackage.References.ToList(), code, filePath); build.Execute(); var engine = new DummyEngine(build.Compiler); var codeCompleter = new CodeCompleter(engine.Compiler, new Source(build.ProjectPackage, filePath.NativePath), new CodeReader(code, caret), caret, Parser.Parse(code)); if (codeCompleter.Context.NodePath.Count < 1) { throw new TestException("Invalid node path was generated for the test case"); } ConfidenceLevel confidenceLevel; var suggestions = codeCompleter.SuggestCompletion("", out confidenceLevel); if (assertCodeSnippets != null) { foreach (var codeSnippet in assertCodeSnippets) { OnAssert(code, codeSnippet, suggestions); } } }
static AbsoluteDirectoryPath GetApmPath() { if (Platform.OperatingSystem == OS.Windows) { var atomPath = ApplicationPaths.AtomPath(); if (!atomPath.HasValue) { //It's not possible to detect the Atom path on Windows 7, so show a message in that case var os = Environment.OSVersion; var win7Info = (os.Platform == PlatformID.Win32NT && os.Version.Major == 6 && os.Version.Minor == 0) ? " Note that we are unable to detect the Atom installation path on Windows 7." : ""; throw new Exception("Failed to find Atom path. Is Atom installed?" + win7Info); } return(atomPath.Value / ".." / "bin" / "apm.cmd"); } else { return(AbsoluteDirectoryPath.Parse("apm")); } }
public void Template03() { if (Directory.Exists("Foo")) { Directory.Delete("Foo", true); } var variableResolver = new VariableResolverDummy( new Dictionary <string, string>() { { "namespace", "Test" }, { "filename", "Foo" } }); var root = AbsoluteDirectoryPath.Parse(Directory.GetCurrentDirectory()); IFileSystem fileSystem = null; // TODO var templates = TemplateLoader.LoadTemplatesFrom(root / "Templates" / "Projects", fileSystem).ToList(); // TODO: real test fs var templateSpawner = new TemplateSpawner(variableResolver, fileSystem); templateSpawner.Spawn(templates[2], root / "Foo"); }
Optional <AbsoluteDirectoryPath> SelectDirectorySync(DirectoryDialogOptions options) { var ofd = new Ookii.Dialogs.Wpf.VistaFolderBrowserDialog { Description = options.Caption, ShowNewFolderButton = true, UseDescriptionForTitle = true, }; if (options.Directory != null) { ofd.SelectedPath = options.Directory.NativePath; } var success = _window == null?ofd.ShowDialog() : ofd.ShowDialog(_window); var path = ofd.SelectedPath; return(success.HasValue && success.Value ? Optional.Some(AbsoluteDirectoryPath.Parse(path)) : Optional.None <AbsoluteDirectoryPath>()); }
public static IEnumerable <AbsoluteDirectoryPath> LookForPathInApplications(string fullName) { var applications = Registry.ClassesRoot.OpenSubKey("Applications"); if (applications != null) { foreach (var application in applications.GetSubKeyNames().Select(keyName => applications.OpenSubKey(keyName))) { if (application.Name.EndsWith(fullName)) { application.GetSubKeyNames().Select(keyName => application.OpenSubKey(keyName)); var kjell = application.OpenSubKey("shell"); var open = kjell.OpenSubKey("open"); var command = open.OpenSubKey("command"); var command_string = (string)command.GetValue(""); var exe_path = command_string.Split(" ")[0].Trim('"'); yield return(AbsoluteDirectoryPath.Parse(exe_path)); } } applications.Close(); } ; }
/// <remarks> This function updates the Result property as a side-effect </remarks> /// <returns> (Started (LogEvent)* [AssemblyBuilt] Ended)* </returns> public IObservable <IBinaryMessage> Build(IObservable <BuildProject> args) { return(args .Switch(a => Observable.Defer(() => { var log = new LogSubject(a.Id); return Observable .Start( () => { lock (_buildLock) return _simulatorBuilder.TryBuild(a, log.Log); }) .Do(_result.OnNext) .SelectMany(result => result.HasValue ? new IBinaryMessage[] { new AssemblyBuilt { Assembly = AbsoluteFilePath.Parse(result.Value.Assembly) }, new Ended { Command = a, Success = true, BuildDirectory = AbsoluteDirectoryPath.Parse(a.OutputDir) }, } : new IBinaryMessage[] { new Ended { Command = a, Success = false, BuildDirectory = AbsoluteDirectoryPath.Parse(a.OutputDir) } }) .StartWith(new Started { Command = a }) .Merge(log.Messages); }))); }
public async Task SetUp() { var project = Substitute.For <IProject>(); project.Classes.Returns(Observable.Return(new IElement[] { })); project.RootDirectory.Returns(Observable.Return(AbsoluteDirectoryPath.Parse("/project"))); var context = Substitute.For <IContext>(); _root = CreateTree(); _fileSystem = Substitute.For <IFileSystem>(); _fileSystem.Exists(Arg.Any <AbsoluteFilePath>()) .Returns( callInfo => { var absoluteFilePath = callInfo.Arg <AbsoluteFilePath>(); var result = absoluteFilePath == AbsoluteFilePath.Parse("/project/MainView.ux"); Console.WriteLine("FileSystem.Exists({0}) -> {1}", absoluteFilePath, result); return(result); }); var panel = await GetTreeChild("Panel"); _currentSelection = new BehaviorSubject <IElement>(panel); context.CurrentSelection.Returns(_currentSelection.Switch()); _classExtractor = new MockedClassExtractor(); _model = new ExtractClassViewModel( context: context, suggestedName: "MyPanel", allClassNames: Observable.Return(new HashSet <string>(new[] { "MyCircle" })), classExtractor: _classExtractor, fileSystem: _fileSystem, project: project); project.Classes.Returns(Observable.Return(new[] { await GetTreeChild("Circle") })); }
public static AbsoluteDirectoryPath GetEnvironmentPath(Environment.SpecialFolder specialFolder) { return(AbsoluteDirectoryPath.Parse(Environment.GetFolderPath(specialFolder))); }
/// <exception cref="BuildFailed"></exception> /// <exception cref="FailedToCreateOutputDir"></exception> public System.Threading.Tasks.Task <BuildResult> BuildUno(Guid id, BuildProject args, PreviewTarget previewTarget, bool driectToDevice, CancellationToken cancellationToken, bool quitAfterApkLaunch) { args.Id = id; var loggedEvents = new AccumulatingProgress <IBinaryMessage>(_buildEvents); var errorList = new ErrorListAdapter(id, loggedEvents); var textWriter = new TextWriterAdapter(id, loggedEvents); var tcs = new TaskCompletionSource <BuildResult>(); var project = _simulatorBuilder.CreateSimulatorProject(args, previewTarget, driectToDevice, quitAfterApkLaunch); var thread = new Thread( () => { var logger = new Log(errorList, textWriter); if (project.IsVerboseBuild) { logger.Level = Uno.Logging.LogLevel.Verbose; } if (project.BuildLibraries) { new LibraryBuilder(new Disk(logger), BuildTargets.Package) { Express = true } } .Build(); var buildTarget = GetBuildTarget(previewTarget); //BuildTarget target; //Enum.TryParse(buildTarget.Identifier, true, out target); _buildEvents.Report( new Started { Command = args }); var faulty = false; try { var buildResult = new ProjectBuilder( logger, buildTarget, project.Options) .Build(project.Project); if (buildResult.ErrorCount != 0) { _errorHelpers.OnBuildFailed(buildResult); tcs.SetException(new UserCodeContainsErrors()); } else { tcs.SetResult(buildResult); } } catch (Exception e) { if (e is ThreadAbortException) { return; } tcs.TrySetException(new InternalBuildError(e)); faulty = true; } finally { _buildEvents.Report( new Ended { Command = args, Success = !faulty, BuildDirectory = AbsoluteDirectoryPath.Parse(project.Project.OutputDirectory) }); } })
public static bool IsInvalid(IAbsolutePath path) { return(Platform.OperatingSystem == OS.Mac && Platform.OperatingSystemVersion >= Platform.ElCapitan && path.IsOrIsRootedIn(AbsoluteDirectoryPath.Parse("/usr/share"))); }
AbsoluteFilePath GetAbsolutePath(SourcePackage p, RelativeFilePath s) { return(AbsoluteDirectoryPath.Parse(p.SourceDirectory) / s); }