{

// ReSharper disable EmptyConstructor

/// <summary>

/// Initializes a new <see cref="DocumentLoader"/> instance.

/// </summary>

protected DocumentLoader()

{

// the help file builder (SHFB) insists on an empty constructor here

}

// ReSharper restore EmptyConstructor

/// <summary>

/// Gets the default document loader.

/// </summary>

public static DocumentLoader Default => DefaultImpl.Instance;

/// <summary>

/// Gets or sets the maximum size of the document loader's cache.

/// </summary>

/// <remarks>

/// This property specifies the maximum number of documents to be cached by the document

/// loader. For the default document loader, its initial value is 1024.

/// </remarks>

/// <seealso cref="Default"/>

public virtual uint MaxCacheSize

{

get => 0;

set => throw new NotSupportedException("The document loader does not support caching");

}

/// <summary>

/// Loads a document.

/// </summary>

/// <param name="settings">Document access settings for the operation.</param>

/// <param name="sourceInfo">An optional structure containing meta-information for the requesting document.</param>

/// <param name="specifier">A string specifying the document to be loaded.</param>

/// <param name="category">An optional category for the requested document.</param>

/// <param name="contextCallback">An optional context callback for the requested document.</param>

/// <returns>A <see cref="Document"/> instance that represents the loaded document.</returns>

/// <remarks>

/// A loaded document must have an absolute <see cref="DocumentInfo.Uri">URI</see>. Once a

/// load operation has completed successfully, subsequent requests that resolve to the same

/// URI are expected to return the same <see cref="Document"/> reference, although loaders

/// are not required to manage document caches of unlimited size.

/// </remarks>

public virtual Document LoadDocument(DocumentSettings settings, DocumentInfo? sourceInfo, string specifier, DocumentCategory category, DocumentContextCallback contextCallback)

{

MiscHelpers.VerifyNonBlankArgument(specifier, nameof(specifier), "Invalid document specifier");

try

{

return LoadDocumentAsync(settings, sourceInfo, specifier, category, contextCallback).Result;

}

catch (AggregateException exception)

{

exception = exception.Flatten();

if (exception.InnerExceptions.Count == 1)

{

throw new FileLoadException(null, specifier, exception.InnerExceptions[0]);

}

throw new FileLoadException(null, specifier, exception);

}

}

/// <summary>

/// Loads a document asynchronously.

/// </summary>

/// <param name="settings">Document access settings for the operation.</param>

/// <param name="sourceInfo">An optional structure containing meta-information for the requesting document.</param>

/// <param name="specifier">A string specifying the document to be loaded.</param>

/// <param name="category">An optional category for the requested document.</param>

/// <param name="contextCallback">An optional context callback for the requested document.</param>

/// <returns>A task that represents the asynchronous operation. Upon completion, the task's result is a <see cref="Document"/> instance that represents the loaded document.</returns>

/// <remarks>

/// A loaded document must have an absolute <see cref="DocumentInfo.Uri">URI</see>. Once a

/// load operation has completed successfully, subsequent requests that resolve to the same

/// URI are expected to return the same <see cref="Document"/> reference, although loaders

/// are not required to manage document caches of unlimited size.

/// </remarks>

public abstract Task<Document> LoadDocumentAsync(DocumentSettings settings, DocumentInfo? sourceInfo, string specifier, DocumentCategory category, DocumentContextCallback contextCallback);

/// <summary>

/// Searches for a cached document by <see cref="DocumentInfo.Uri">URI</see>.

/// </summary>

/// <param name="uri">The document URI for which to search.</param>

/// <returns>The cached document if it was found, <c>null</c> otherwise.</returns>

public virtual Document GetCachedDocument(Uri uri)

{

return null;

}

/// <summary>

/// Stores a document in the cache.

/// </summary>

/// <param name="document">The document to store in the cache.</param>

/// <param name="replace"><c>True</c> to replace any existing document with the same URI, <c>false</c> otherwise.</param>

/// <returns>The cached document, which may be different from <paramref name="document"/> if <paramref name="replace"/> is <c>false</c>.</returns>

/// <remarks>

/// A cached document must have an absolute <see cref="DocumentInfo.Uri">URI</see>.

/// </remarks>

public virtual Document CacheDocument(Document document, bool replace)

{

throw new NotSupportedException("The document loader does not support caching");

}

/// <summary>

/// Discards all cached documents.

/// </summary>

public virtual void DiscardCachedDocuments()

{

}

#region Nested type: IStatistics

internal interface IStatistics

{

long FileCheckCount { get; }

long WebCheckCount { get; }

void ResetCheckCounts();

}

#endregion

#region Nested type: DefaultImpl

private sealed class DefaultImpl : DocumentLoader, IStatistics

{

public static readonly DefaultImpl Instance = new DefaultImpl();

private static readonly IReadOnlyCollection<string> relativePrefixes = new List<string>

{

"." + Path.DirectorySeparatorChar,

"." + Path.AltDirectorySeparatorChar,

".." + Path.DirectorySeparatorChar,

".." + Path.AltDirectorySeparatorChar,

};

private readonly List<Document> cache = new List<Document>();

private long fileCheckCount;

private long webCheckCount;

private DefaultImpl()

{

MaxCacheSize = 1024;

}

private Task<(Document, List<Uri>)> GetCachedDocumentOrCandidateUrisAsync(DocumentSettings settings, DocumentInfo? sourceInfo, Uri uri)

{

return GetCachedDocumentOrCandidateUrisWorkerAsync(settings, sourceInfo, uri.ToEnumerable());

}

private Task<(Document, List<Uri>)> GetCachedDocumentOrCandidateUrisAsync(DocumentSettings settings, DocumentInfo? sourceInfo, string specifier)

{

return GetCachedDocumentOrCandidateUrisWorkerAsync(settings, sourceInfo, GetRawUris(settings, sourceInfo, specifier).Distinct());

}

private async Task<(Document, List<Uri>)> GetCachedDocumentOrCandidateUrisWorkerAsync(DocumentSettings settings, DocumentInfo? sourceInfo, IEnumerable<Uri> rawUris)

{

if (!string.IsNullOrWhiteSpace(settings.FileNameExtensions))

{

rawUris = rawUris.SelectMany(uri => ApplyExtensions(sourceInfo, uri, settings.FileNameExtensions));

}

var testUris = rawUris.ToList();

foreach (var testUri in testUris)

{

var flag = testUri.IsFile ? DocumentAccessFlags.EnableFileLoading : DocumentAccessFlags.EnableWebLoading;

if (settings.AccessFlags.HasFlag(flag))

{

var document = GetCachedDocument(testUri);

if (document != null)

{

return (document, null);

}

}

}

var candidateUris = new List<Uri>();

foreach (var testUri in testUris)

{

if (await IsCandidateUriAsync(settings, testUri).ConfigureAwait(false))

{

candidateUris.Add(testUri);

}

}

return (null, candidateUris);

}

private static IEnumerable<Uri> GetRawUris(DocumentSettings settings, DocumentInfo? sourceInfo, string specifier)

{

Uri baseUri;

Uri uri;

if (sourceInfo.HasValue && SpecifierMayBeRelative(settings, specifier))

{

baseUri = GetBaseUri(sourceInfo.Value);

if ((baseUri != null) && Uri.TryCreate(baseUri, specifier, out uri))

{

yield return uri;

}

}

var searchPath = settings.SearchPath;

if (!string.IsNullOrWhiteSpace(searchPath))

{

foreach (var url in searchPath.SplitSearchPath())

{

if (Uri.TryCreate(url, UriKind.Absolute, out baseUri) && TryCombineSearchUri(baseUri, specifier, out uri))

{

yield return uri;

}

}

}

if (MiscHelpers.Try(out var path, () => Path.Combine(Directory.GetCurrentDirectory(), specifier)) && Uri.TryCreate(path, UriKind.Absolute, out uri))

{

yield return uri;

}

if (MiscHelpers.Try(out path, () => Path.Combine(AppDomain.CurrentDomain.BaseDirectory, specifier)) && Uri.TryCreate(path, UriKind.Absolute, out uri))

{

yield return uri;

}

using (var process = Process.GetCurrentProcess())

{

var module = process.MainModule;

if ((module != null) && Uri.TryCreate(module.FileName, UriKind.Absolute, out baseUri) && Uri.TryCreate(baseUri, specifier, out uri))

{

yield return uri;

}

}

}

private static IEnumerable<Uri> ApplyExtensions(DocumentInfo? sourceInfo, Uri uri, string extensions)

{

yield return uri;

var builder = new UriBuilder(uri);

var path = builder.Path;

if (!string.IsNullOrEmpty(Path.GetFileName(path)))

{

var existingExtension = Path.GetExtension(path);

var compatibleExtensions = GetCompatibleExtensions(sourceInfo, extensions).ToList();

if (!compatibleExtensions.Contains(existingExtension, StringComparer.OrdinalIgnoreCase))

{

foreach (var compatibleExtension in compatibleExtensions)

{

builder.Path = Path.ChangeExtension(path, existingExtension + compatibleExtension);

yield return builder.Uri;

}

}

}

}

private static IEnumerable<string> GetCompatibleExtensions(DocumentInfo? sourceInfo, string extensions)

{

string sourceExtension = null;

if (sourceInfo.HasValue)

{

sourceExtension = Path.GetExtension((sourceInfo.Value.Uri != null) ? new UriBuilder(sourceInfo.Value.Uri).Path : sourceInfo.Value.Name);

if (!string.IsNullOrEmpty(sourceExtension))

{

yield return sourceExtension;

}

}

foreach (var extension in extensions.SplitSearchPath())

{

var tempExtension = extension.StartsWith(".", StringComparison.Ordinal) ? extension : "." + extension;

if (!tempExtension.Equals(sourceExtension, StringComparison.OrdinalIgnoreCase))

{

yield return tempExtension;

}

}

}

private static bool SpecifierMayBeRelative(DocumentSettings settings, string specifier)

{

return !settings.AccessFlags.HasFlag(DocumentAccessFlags.EnforceRelativePrefix) || relativePrefixes.Any(specifier.StartsWith);

}

private static Uri GetBaseUri(DocumentInfo sourceInfo)

{

var sourceUri = sourceInfo.Uri;

if ((sourceUri == null) && !Uri.TryCreate(sourceInfo.Name, UriKind.RelativeOrAbsolute, out sourceUri))

{

return null;

}

if (!sourceUri.IsAbsoluteUri)

{

return null;

}

return sourceUri;

}

private static bool TryCombineSearchUri(Uri searchUri, string specifier, out Uri uri)

{

var searchUrl = searchUri.AbsoluteUri;

if (!searchUrl.EndsWith("/", StringComparison.Ordinal))

{

searchUri = new Uri(searchUrl + "/");

}

return Uri.TryCreate(searchUri, specifier, out uri);

}

private async Task<bool> IsCandidateUriAsync(DocumentSettings settings, Uri uri)

{

return uri.IsFile ?

settings.AccessFlags.HasFlag(DocumentAccessFlags.EnableFileLoading) && await FileDocumentExistsAsync(uri.LocalPath).ConfigureAwait(false) :

settings.AccessFlags.HasFlag(DocumentAccessFlags.EnableWebLoading) && await WebDocumentExistsAsync(uri).ConfigureAwait(false);

}

private Task<bool> FileDocumentExistsAsync(string path)

{

Interlocked.Increment(ref fileCheckCount);

return Task.FromResult(File.Exists(path));

}

private async Task<bool> WebDocumentExistsAsync(Uri uri)

{

Interlocked.Increment(ref webCheckCount);

using (var client = new HttpClient())

{

using (var request = new HttpRequestMessage(HttpMethod.Head, uri))

{

try

{

using (var response = await client.SendAsync(request).ConfigureAwait(false))

{

return response.IsSuccessStatusCode;

}

}

catch (HttpRequestException)

{

return false;

}

}

}

}

private async Task<Document> LoadDocumentAsync(DocumentSettings settings, Uri uri, DocumentCategory category, DocumentContextCallback contextCallback)

{

if (uri.IsFile)

{

if (!settings.AccessFlags.HasFlag(DocumentAccessFlags.EnableFileLoading))

{

throw new UnauthorizedAccessException("The script engine is not configured for loading documents from the file system");

}

}

else

{

if (!settings.AccessFlags.HasFlag(DocumentAccessFlags.EnableWebLoading))

{

throw new UnauthorizedAccessException("The script engine is not configured for downloading documents from the Web");

}

}

var cachedDocument = GetCachedDocument(uri);

if (cachedDocument != null)

{

return cachedDocument;

}

string contents;

if (uri.IsFile)

{

using (var reader = new StreamReader(uri.LocalPath))

{

contents = await reader.ReadToEndAsync().ConfigureAwait(false);

}

}

else

{

using (var client = new HttpClient())

{

contents = await client.GetStringAsync(uri).ConfigureAwait(false);

}

}

var documentInfo = new DocumentInfo(uri) { Category = category, ContextCallback = contextCallback };

var callback = settings.LoadCallback;

callback?.Invoke(ref documentInfo);

return CacheDocument(new StringDocument(documentInfo, contents), false);

}

#region DocumentLoader overrides

public override uint MaxCacheSize { get; set; }

public override async Task<Document> LoadDocumentAsync(DocumentSettings settings, DocumentInfo? sourceInfo, string specifier, DocumentCategory category, DocumentContextCallback contextCallback)

{

MiscHelpers.VerifyNonNullArgument(settings, nameof(settings));

MiscHelpers.VerifyNonBlankArgument(specifier, nameof(specifier), "Invalid document specifier");

if ((settings.AccessFlags & DocumentAccessFlags.EnableAllLoading) == DocumentAccessFlags.None)

{

throw new UnauthorizedAccessException("The script engine is not configured for loading documents");

}

if (category == null)

{

category = sourceInfo.HasValue ? sourceInfo.Value.Category : DocumentCategory.Script;

}

(Document Document, List<Uri> CandidateUris) result;

if (Uri.TryCreate(specifier, UriKind.RelativeOrAbsolute, out var uri) && uri.IsAbsoluteUri)

{

result = await GetCachedDocumentOrCandidateUrisAsync(settings, sourceInfo, uri).ConfigureAwait(false);

}

else

{

result = await GetCachedDocumentOrCandidateUrisAsync(settings, sourceInfo, specifier).ConfigureAwait(false);

}

if (result.Document != null)

{

return result.Document;

}

if (result.CandidateUris.Count < 1)

{

throw new FileNotFoundException(null, specifier);

}

if (result.CandidateUris.Count == 1)

{

return await LoadDocumentAsync(settings, result.CandidateUris[0], category, contextCallback).ConfigureAwait(false);

}

var exceptions = new List<Exception>(result.CandidateUris.Count);

foreach (var candidateUri in result.CandidateUris)

{

var task = LoadDocumentAsync(settings, candidateUri, category, contextCallback);

try

{

return await task.ConfigureAwait(false);

}

catch (Exception exception)

{

if ((task.Exception != null) && task.Exception.InnerExceptions.Count == 1)

{

Debug.Assert(ReferenceEquals(task.Exception.InnerExceptions[0], exception));

exceptions.Add(exception);

}

else

{

exceptions.Add(task.Exception);

}

}

}

if (exceptions.Count < 1)

{

MiscHelpers.AssertUnreachable();

throw new FileNotFoundException(null, specifier);

}

if (exceptions.Count == 1)

{

MiscHelpers.AssertUnreachable();

throw new FileLoadException(exceptions[0].Message, specifier, exceptions[0]);

}

throw new AggregateException(exceptions).Flatten();

}

public override Document GetCachedDocument(Uri uri)

{

lock (cache)

{

for (var index = 0; index < cache.Count; index++)

{

var cachedDocument = cache[index];

if (cachedDocument.Info.Uri == uri)

{

cache.RemoveAt(index);

cache.Insert(0, cachedDocument);

return cachedDocument;

}

}

return null;

}

}

public override Document CacheDocument(Document document, bool replace)

{

MiscHelpers.VerifyNonNullArgument(document, nameof(document));

if (!document.Info.Uri.IsAbsoluteUri)

{

throw new ArgumentException("The document must have an absolute URI");

}

lock (cache)

{

for (var index = 0; index < cache.Count;)

{

var cachedDocument = cache[index];

if (cachedDocument.Info.Uri != document.Info.Uri)

{

index++;

}

else

{

if (!replace)

{

Debug.Assert(cachedDocument.Contents.ReadToEnd().SequenceEqual(document.Contents.ReadToEnd()));

return cachedDocument;

}

cache.RemoveAt(index);

}

}

var maxCacheSize = Math.Max(16, Convert.ToInt32(Math.Min(MaxCacheSize, int.MaxValue)));

while (cache.Count >= maxCacheSize)

{

cache.RemoveAt(cache.Count - 1);

}

cache.Insert(0, document);

return document;

}

}

public override void DiscardCachedDocuments()

{

lock (cache)

{

cache.Clear();

}

}

#endregion

#region IStatistics implementation

long IStatistics.FileCheckCount => Interlocked.Read(ref fileCheckCount);

long IStatistics.WebCheckCount => Interlocked.Read(ref webCheckCount);

void IStatistics.ResetCheckCounts()

{

Interlocked.Exchange(ref fileCheckCount, 0);

Interlocked.Exchange(ref webCheckCount, 0);

}

#endregion

}

#endregion