public void Load(IScriptAnalyzerContext context, LoadReference reference) { #if NETCORE throw new NotSupportedException("The NuGet provider for #load is not supported on .NET Core."); #else // Create a package reference from our load reference. // The package should contain the necessary include parameters to make sure // that .cake files are included as part of the result. var separator = reference.OriginalString.Contains("?") ? "&" : "?"; var uri = string.Concat(reference.OriginalString, $"{separator}include=./**/*.cake"); var package = new PackageReference(uri); // Find the tool folder. var toolPath = GetToolPath(context.Root.GetDirectory()); // Install the NuGet package. var files = _installer.Install(package, PackageType.Tool, toolPath); if (files.Count == 0) { // No files found. _log.Warning("No scripts found in NuGet package {0}.", package.Package); return; } foreach (var file in files) { var extension = file.Path.GetExtension(); if (extension != null && extension.Equals(".cake", StringComparison.OrdinalIgnoreCase)) { context.Analyze(file.Path); } } #endif }
/// <summary> /// Load the given reference /// </summary> /// <returns>The load.</returns> /// <param name="context">The context.</param> /// <param name="reference">The load reference.</param> public void Load(IScriptAnalyzerContext context, LoadReference reference) { var urlsPath = GetUrlsPath(context.Root.GetDirectory()); var actualUrl = reference.Address; var referenceHash = HashMd5(actualUrl.ToString()); var urlFile = urlsPath.CombineWithFilePath(referenceHash + ".cake").MakeAbsolute(_environment); if (!System.IO.File.Exists(urlFile.FullPath)) { var urlFileDir = urlFile.GetDirectory().FullPath; // Make sure the directory exists we want to save to if (!System.IO.Directory.Exists(urlFileDir)) { System.IO.Directory.CreateDirectory(urlFileDir); } var http = new System.Net.Http.HttpClient(); using (var httpStream = http.GetStreamAsync(actualUrl).Result) using (var cacheStream = System.IO.File.Create(urlFile.MakeAbsolute(_environment).FullPath)) { httpStream.CopyTo(cacheStream); } } context.Analyze(urlFile); }
public void Should_Not_CanLoad(string url) { var f = new UrlLoadDirectiveProviderFixture(); var lr = new LoadReference(new Uri(url)); var r = f.CanLoad(lr); Assert.False(r); }
public NuGetLoadDirectiveProviderFixture() { Environment = FakeEnvironment.CreateUnixEnvironment(); Installer = Substitute.For <INuGetPackageInstaller>(); Configuration = new FakeConfiguration(); Log = new FakeLog(); Reference = new LoadReference(new Uri("nuget:?package=Cake.Recipe")); InstallResult = new List <FilePath>(); Context = Substitute.For <IScriptAnalyzerContext>(); Context.Root.Returns(new FilePath("/Working/build.cake")); }
protected override void AddToContext(IScriptAnalyzerContext context, Uri uri) { var reference = new LoadReference(uri); foreach (var provider in _providers) { if (provider.CanLoad(context, reference)) { provider.Load(context, reference); } } }
public void Load_Url_Reference(string url) { var f = new UrlLoadDirectiveProviderFixture(); var lr = new LoadReference(new Uri(url)); f.Load(lr); Assert.NotEmpty(f.LoadedReferences); foreach (var k in f.LoadedReferences.Keys) { Console.WriteLine(k); } }
public void Load(IScriptAnalyzerContext context, LoadReference reference) { // Create a package reference from our load reference. // If not specified in script, the package should contain the necessary include // parameters to make sure that .cake files are included as part of the result. var uri = new Uri(reference.OriginalString); var parameters = uri.GetQueryString(); const string includeParameterName = "include"; if (!parameters.ContainsKey(includeParameterName)) { var separator = parameters.Count > 0 ? "&" : "?"; uri = new Uri(string.Concat(reference.OriginalString, $"{separator}include=./**/*.cake")); } var package = new PackageReference(uri); // Find the tool folder. var toolPath = GetToolPath(_environment.WorkingDirectory); // Install the NuGet package. var files = _installer .Install(package, PackageType.Tool, toolPath) .Where(file => { var extension = file.Path.GetExtension(); return(extension != null && extension.Equals(".cake", StringComparison.OrdinalIgnoreCase)); }) .ToArray(); if (files.Length == 0) { // No scripts found. _log.Warning("No scripts found in NuGet package {0}.", package.Package); return; } foreach (var file in files) { context.Analyze(file.Path); } }
public void Load(IScriptAnalyzerContext context, LoadReference reference) { if (!_cache.TryGetValue(reference, out IReadOnlyList <FilePath> result)) { var provider = _loadDirectiveProviders.FirstOrDefault(x => x.CanLoad(context, reference)); if (provider == null) { return; } var interceptor = new InterceptingScriptAnalyzerContext(context); provider.Load(interceptor, reference); result = interceptor.FilePaths; _cache.Add(reference, result); } foreach (var file in result ?? Enumerable.Empty <FilePath>()) { context.Analyze(file); } }
public bool CanLoad(IScriptAnalyzerContext context, LoadReference reference) { return(reference.Scheme != null && reference.Scheme.Equals("nuget", StringComparison.OrdinalIgnoreCase)); }
public bool CanLoad(IScriptAnalyzerContext context, LoadReference reference) { return(_loadDirectiveProviders.Any(x => x.CanLoad(context, reference))); }
/// <summary> /// Loads and displays the specified fileReference in the UI, which is expected to point to a valid object. /// This function takes a delegate which will correctly load the file pointed to by the FileReference, /// and another delegate which will create a correct <see cref="IRenderable"/> object from the resulting /// object. /// </summary> /// <param name="fileReference">A <see cref="FileReference"/> which points to the desired file.</param> /// <param name="referenceLoadingRoutine">A delegate which correctly loads the desired file, returning a generic type T.</param> /// <param name="createRenderable">A delegate which accepts a generic type T and returns a renderable object.</param> /// <param name="associatedControlPage">The control page which the file is associated with, that is, the one with relevant controls.</param> /// <param name="ct">A cancellation token for this operation.</param> /// <typeparam name="T">The type of object to load.</typeparam> private async Task DisplayRenderableFile <T>(FileReference fileReference, LoadReference <T> referenceLoadingRoutine, CreateRenderable <T> createRenderable, ControlPage associatedControlPage, CancellationToken ct) { if (fileReference == null) { throw new ArgumentNullException(nameof(fileReference)); } Log.Info($"Loading \"{fileReference.FilePath}\"."); this.StatusSpinner.Active = true; string modelName = fileReference.Filename; uint modelStatusMessageContextID = this.MainStatusBar.GetContextId($"itemLoad_{modelName}"); uint modelStatusMessageID = this.MainStatusBar.Push ( modelStatusMessageContextID, $"Loading \"{modelName}\"..." ); try { T item = await Task.Run ( () => referenceLoadingRoutine(fileReference), ct ); IRenderable renderable = await Task.Factory.StartNew ( () => createRenderable(item, fileReference), ct ); if (renderable != null) { ct.ThrowIfCancellationRequested(); this.ViewportWidget.MakeCurrent(); this.ViewportWidget.AttachBuffers(); renderable.Initialize(); // Replace the renderable on the UI thread await Task.Factory.StartNew ( () => this.RenderingEngine.SetRenderTarget(renderable), ct, TaskCreationOptions.None, this.UiThreadScheduler ); EnableControlPage(associatedControlPage); if (renderable is IModelInfoProvider infoProvider) { this.PolyCountLabel.Text = infoProvider.PolygonCount.ToString(); this.VertexCountLabel.Text = infoProvider.VertexCount.ToString(); } } } catch (OperationCanceledException) { Log.Info($"Cancelled loading of {fileReference.Filename}"); } finally { this.StatusSpinner.Active = false; this.MainStatusBar.Remove(modelStatusMessageContextID, modelStatusMessageID); } }
internal void Load(LoadReference loadRef) { var p = CreateProvider(); p.Load(ScriptAnalyzerContext, loadRef); }
internal bool CanLoad(LoadReference loadRef) { var p = CreateProvider(); return(p.CanLoad(ScriptAnalyzerContext, loadRef)); }