protected override async Task <IEnumerable <IDocument> > ExecuteAsync(IDocument input, IExecutionContext context, object value) { if (value != null) { try { JsonSerializerSettings settings = new JsonSerializerSettings() { Formatting = _indenting ? Formatting.Indented : Formatting.None }; if (_camelCase) { settings.ContractResolver = new CamelCasePropertyNamesContractResolver(); } _settings?.Invoke(settings); string result = JsonConvert.SerializeObject(value, settings); if (string.IsNullOrEmpty(_destinationKey)) { return(input.Clone(await context.GetContentProviderAsync(result)).Yield()); } return(input .Clone(new MetadataItems { { _destinationKey, result } }) .Yield()); } catch (Exception ex) { // Return original input on exception context.LogError($"Error serializing JSON for {input.ToSafeDisplayString()}, returning original input document: {ex}"); } } return(input.Yield()); }
protected override async Task <IEnumerable <IDocument> > ExecuteInputAsync(IDocument input, IExecutionContext context) { string fileName = _fileName == null ? input.Destination.FileName.FullPath : await _fileName.GetValueAsync(input, context); if (!string.IsNullOrWhiteSpace(fileName)) { fileName = GetFileName(fileName); if (!string.IsNullOrWhiteSpace(fileName)) { if (_fileName == null || string.IsNullOrWhiteSpace(_outputKey)) { // No output key so set the destination FilePath path = input.Destination.ChangeFileName(fileName); return(input.Clone(path).Yield()); } else { // Set the specified output key return(input.Clone( new MetadataItems { { _outputKey, fileName } }) .Yield()); } } } return(input.Yield()); }
/// <inheritdoc /> protected override async Task <IEnumerable <IDocument> > ExecuteConfigAsync(IDocument input, IExecutionContext context, string value) { if (value == null) { value = string.Empty; } if (string.IsNullOrEmpty(_search)) { return(input.Yield()); } string currentDocumentContent = await input.GetContentStringAsync(); if (_contentFinder != null) { string newDocumentContent = Regex.Replace( currentDocumentContent, _search, match => _contentFinder(match, input)?.ToString() ?? string.Empty, _regexOptions); return((currentDocumentContent == newDocumentContent ? input : input.Clone(await context.GetContentProviderAsync(newDocumentContent))) .Yield()); } string replaced = _isRegex ? Regex.Replace(currentDocumentContent, _search, value, _regexOptions) : currentDocumentContent.Replace(_search, value); return(input.Clone(await context.GetContentProviderAsync(replaced)).Yield()); }
protected override async Task <IEnumerable <IDocument> > ExecuteAsync(IDocument input, IExecutionContext context) { context.LogDebug($"Processing Sass for {input.ToSafeDisplayString()}"); FilePath inputPath = await _inputPath.GetValueAsync(input, context); if (inputPath?.IsAbsolute != true) { inputPath = context.FileSystem.GetInputFile(new FilePath(Path.GetRandomFileName())).Path; context.LogWarning($"No input path found for document {input.ToSafeDisplayString()}, using {inputPath.FileName.FullPath}"); } string content = await input.GetStringAsync(); // Sass conversion FileImporter importer = new FileImporter(context.FileSystem, _importPathFunc); ScssOptions options = new ScssOptions { OutputStyle = _outputStyle, GenerateSourceMap = _generateSourceMap, SourceComments = _includeSourceComments, InputFile = inputPath.FullPath, TryImport = importer.TryImport }; IEnumerable <string> includePaths = _includePaths .Where(x => x != null) .Select(x => x.IsAbsolute ? x.FullPath : context.FileSystem.GetContainingInputPath(x)?.Combine(x)?.FullPath) .Where(x => x != null); options.IncludePaths.AddRange(includePaths); ScssResult result = Scss.ConvertToCss(content, options); // Process the result DirectoryPath relativeDirectory = context.FileSystem.GetContainingInputPath(inputPath); FilePath relativePath = relativeDirectory?.GetRelativePath(inputPath) ?? inputPath.FileName; FilePath cssPath = relativePath.ChangeExtension("css"); IDocument cssDocument = input.Clone( cssPath, await context.GetContentProviderAsync(result.Css ?? string.Empty)); // Generate a source map if requested if (_generateSourceMap && result.SourceMap != null) { FilePath sourceMapPath = relativePath.ChangeExtension("map"); IDocument sourceMapDocument = input.Clone( sourceMapPath, await context.GetContentProviderAsync(result.SourceMap)); return(new[] { cssDocument, sourceMapDocument }); } return(cssDocument.Yield()); }
protected override IEnumerable <IDocument> Execute(object content, IDocument input, IExecutionContext context) { if (content == null) { content = string.Empty; } if (string.IsNullOrEmpty(_search)) { return(new[] { input.Clone(content.ToString()) }); } return(new[] { input.Clone(content.ToString().Replace(_search, input.Content)) }); }
protected override IEnumerable<IDocument> Execute(object content, IDocument input, IExecutionContext context) { if (content == null) { content = string.Empty; } if (string.IsNullOrEmpty(_search)) { return new[] { input.Clone(content.ToString()) }; } return new[] { input.Clone(content.ToString().Replace(_search, input.Content)) }; }
protected override async Task <IEnumerable <IDocument> > ExecuteInputAsync(IDocument input, IExecutionContext context) { MetadataDictionary metadata; using (Stream contentStream = input.GetContentStream()) { metadata = await JsonSerializer.DeserializeAsync <MetadataDictionary>(contentStream, _options, context.CancellationToken); } if (!string.IsNullOrEmpty(_key)) { input = input.Clone(new[] { new KeyValuePair <string, object>(_key, metadata) }); } return(_populateDocument ? input.Clone(metadata).Yield() : input.Yield()); }
protected override Task <IEnumerable <IDocument> > ExecuteConfigAsync(IDocument input, IExecutionContext context, object value) => Task.FromResult( (_onlyIfNonExisting && input.ContainsKey(_key)) || (_ignoreNull && value == null) ? input.Yield() : input.Clone(new MetadataItems { { _key, value } }).Yield());
public static IDocument CloneOrCreateDocument( this IDocumentFactory documentFactory, IDocument document, NormalizedPath destination, IContentProvider contentProvider = null) => document?.Clone(destination, contentProvider) ?? documentFactory.CreateDocument(destination, contentProvider);
/// <inheritdoc /> protected override async Task <IEnumerable <IDocument> > ExecuteAsync(IDocument input, IExecutionContext context) { FilePath sidecarPath = await _sidecarPath.GetValueAsync(input, context); if (sidecarPath != null) { IFile sidecarFile = context.FileSystem.GetInputFile(sidecarPath); if (sidecarFile.Exists) { string sidecarContent = await sidecarFile.ReadAllTextAsync(); foreach (IDocument result in await context.ExecuteModulesAsync(Children, input.Clone(await context.GetContentProviderAsync(sidecarContent)).Yield())) { return(input.Clone(result).Yield()); } } else { return(input.Yield()); } } else { return(input.Yield()); } return(null); }
protected override async Task <IEnumerable <IDocument> > ExecuteInputAsync(IDocument input, IExecutionContext context) { byte[] assembly = ScriptHelper.Compile(await input.GetContentStringAsync(), input, context); MemoryStream stream = context.MemoryStreamFactory.GetStream(assembly); return(input.Clone(context.GetContentProvider(stream, ScriptMediaType)).Yield()); }
private async Task <InsertingStreamLocation> ExecuteShortcodesAsync( IDocument input, IExecutionContext context, ShortcodeLocation location, ImmutableDictionary <string, IShortcode> shortcodes) { // Execute the shortcode IDocument shortcodeResult = await shortcodes[location.Name].ExecuteAsync(location.Arguments, location.Content, input, context); IDocument mergedResult = null; if (shortcodeResult != null) { // Merge output metadata with the current input document // Creating a new document is the easiest way to ensure all the metadata from shortcodes gets accumulated correctly mergedResult = input.Clone(shortcodeResult, shortcodeResult.ContentProvider); // Don't process nested shortcodes if it's the raw shortcode if (!location.Name.Equals(RawShortcode.RawShortcodeName, StringComparison.OrdinalIgnoreCase)) { // Recursively parse shortcodes IDocument nestedResult = await ProcessShortcodesAsync(mergedResult, context); if (nestedResult != null) { mergedResult = nestedResult; } } return(new InsertingStreamLocation(location.FirstIndex, location.LastIndex, mergedResult)); } return(new InsertingStreamLocation(location.FirstIndex, location.LastIndex, mergedResult)); }
public static IDocument CloneOrCreateDocument( this IDocumentFactory documentFactory, IDocument document, IEnumerable <KeyValuePair <string, object> > items, IContentProvider contentProvider = null) => document?.Clone(items, contentProvider) ?? documentFactory.CreateDocument(items, contentProvider);
protected override IEnumerable <IDocument> Execute(IDocument input, IExecutionContext context) { List <Dictionary <string, object> > documentMetadata = new List <Dictionary <string, object> >(); using (TextReader contentReader = new StreamReader(input.GetStream())) { YamlStream yamlStream = new YamlStream(); yamlStream.Load(contentReader); foreach (YamlDocument document in yamlStream.Documents) { // If this is a sequence, get a document for each item if (document.RootNode is YamlSequenceNode rootSequence) { documentMetadata.AddRange(rootSequence.Children.Select(x => GetDocumentMetadata(x, context))); } else { // Otherwise, just get a single set of metadata documentMetadata.Add(GetDocumentMetadata(document.RootNode, context)); } } } if (documentMetadata.Count == 0 && _flatten) { return(input.Yield()); } return(documentMetadata.Select(metadata => input.Clone(metadata))); }
// Stream /// <summary> /// Clones this document. /// </summary> /// <param name="document">The document.</param> /// <param name="destination">The new destination or <c>null</c> to keep the existing destination.</param> /// <param name="items">New metadata items.</param> /// <param name="stream">A stream that contains the new content.</param> /// <param name="mediaType">The media type of the content.</param> /// <returns>A new document of the same type as this document.</returns> public static IDocument Clone( this IDocument document, NormalizedPath destination, IEnumerable <KeyValuePair <string, object> > items, Stream stream, string mediaType = null) => document.Clone(null, destination, items, IExecutionContext.Current.GetContentProvider(stream, mediaType));
/// <summary> /// Clones this document. /// </summary> /// <param name="document">The document.</param> /// <param name="source">The new source. If this document already contains a source, then it's used and this is ignored.</param> /// <param name="destination">The new destination or <c>null</c> to keep the existing destination.</param> /// <param name="content">The new content.</param> /// <param name="mediaType">The media type of the content.</param> /// <returns>A new document of the same type as this document.</returns> public static async Task <IDocument> CloneAsync( this IDocument document, NormalizedPath source, NormalizedPath destination, string content, string mediaType = null) => document.Clone(source, destination, null, await IExecutionContext.Current.GetContentProviderAsync(content, mediaType));
// String /// <summary> /// Clones this document. /// </summary> /// <param name="document">The document.</param> /// <param name="destination">The new destination or <c>null</c> to keep the existing destination.</param> /// <param name="items">New metadata items.</param> /// <param name="content">The new content.</param> /// <param name="mediaType">The media type of the content.</param> /// <returns>A new document of the same type as this document.</returns> public static async Task <IDocument> CloneAsync( this IDocument document, NormalizedPath destination, IEnumerable <KeyValuePair <string, object> > items, string content, string mediaType = null) => document.Clone(null, destination, items, await IExecutionContext.Current.GetContentProviderAsync(content, mediaType));
/// <summary> /// Clones this document. /// </summary> /// <param name="document">The document.</param> /// <param name="source">The new source. If this document already contains a source, then it's used and this is ignored.</param> /// <param name="destination">The new destination or <c>null</c> to keep the existing destination.</param> /// <param name="stream">A stream that contains the new content.</param> /// <param name="mediaType">The media type of the content.</param> /// <returns>A new document of the same type as this document.</returns> public static IDocument Clone( this IDocument document, NormalizedPath source, NormalizedPath destination, Stream stream, string mediaType = null) => document.Clone(source, destination, null, IExecutionContext.Current.GetContentProvider(stream, mediaType));
public static IDocument CloneOrCreateDocument( this IExecutionContext context, IDocument document, Stream stream, string mediaType = null) => document?.Clone(context.GetContentProvider(stream, mediaType)) ?? context.CreateDocument(context.GetContentProvider(stream, mediaType));
/// <inheritdoc /> protected override async Task <IEnumerable <IDocument> > ExecuteInputAsync(IDocument input, IExecutionContext context) { NormalizedPath sidecarPath = await _sidecarPath.GetValueAsync(input, context); if (!sidecarPath.IsNull) { IFile sidecarFile = context.FileSystem.GetInputFile(sidecarPath); if (sidecarFile.Exists) { IContentProvider sidecarContent = sidecarFile.GetContentProvider(); foreach (IDocument result in await context.ExecuteModulesAsync(Children, input.Clone(sidecarContent).Yield())) { return(input.Clone(result).Yield()); } } else { return(input.Yield()); } } else { return(input.Yield()); } return(null); }
public static async Task <IDocument> CloneOrCreateDocumentAsync( this IExecutionContext context, IDocument document, string content, string mediaType = null) => document?.Clone(await context.GetContentProviderAsync(content, mediaType)) ?? context.CreateDocument(await context.GetContentProviderAsync(content, mediaType));
protected override async Task <IEnumerable <IDocument> > ExecuteAsync(IDocument input, IExecutionContext context) { IEnumerable <IEnumerable <string> > records; using (Stream stream = input.GetStream()) { records = CsvFile.GetAllRecords(stream); } StringBuilder builder = new StringBuilder(); bool firstLine = true; builder.AppendLine("<table>"); foreach (IEnumerable <string> row in records) { builder.AppendLine("<tr>"); foreach (string cell in row) { if (_firstLineHeader && firstLine) { builder.AppendLine($"<th>{cell}</th>"); } else { builder.AppendLine($"<td>{cell}</td>"); } } builder.AppendLine("</tr>"); firstLine = false; } builder.Append("</table>"); return(input.Clone(await context.GetContentProviderAsync(builder.ToString())).Yield()); }
protected override Task <IEnumerable <IDocument> > ExecuteInputAsync(IDocument input, IExecutionContext context) { if (input.TryGetValue(_fromKey, out object existingValue)) { if (_format != null) { if (existingValue is DateTime) { existingValue = ((DateTime)existingValue).ToString(_format); } else { existingValue = string.Format(_format, existingValue); } } if (_formatFunc != null) { existingValue = _formatFunc.Invoke(existingValue.ToString()); } return(input.Clone(new[] { new KeyValuePair <string, object>(_toKey, existingValue) }).YieldAsync()); } else { return(input.YieldAsync()); } }
protected override async Task <IEnumerable <IDocument> > ExecuteInputAsync(IDocument input, IExecutionContext context) { var html = await HtmlHelper.ParseHtmlAsync(input); if (html is null) { return(input.Yield()); } // Assumes there is at least on he heading in the document. // All h2 headings become entries in the table-of-contents, all h3 headings between two h2 elements // are output as children of the preceding h2 // if the document starts with a h3 heading, return unchanged input document var elements = html.QuerySelectorAll("h2, h3"); if ((elements.FirstOrDefault() as IHtmlHeadingElement)?.NodeName?.Equals("h2", StringComparison.OrdinalIgnoreCase) != true) { return(input.Yield()); } var toc = new List <TocEntry>(); var currentEntry = default(TocEntry); foreach (var element in elements) { if (element is IHtmlHeadingElement heading) { var level = Int32.Parse(element.NodeName.Substring(1)); if (level == 2) { currentEntry = GetTocEntry(heading); toc.Add(currentEntry); } else if (level == 3) { if (currentEntry == null) { throw new InvalidOperationException(); } var childEntry = GetTocEntry(heading); currentEntry.Items.Add(childEntry); } else { throw new InvalidOperationException(); } } } var newMetadata = new Dictionary <string, object>() { { DocsTemplateKeys.ToC, toc.Select(x => x.ToDocument(context)).ToArray() } }; return(input.Clone(newMetadata).Yield()); }
protected override async Task <IEnumerable <IDocument> > ExecuteConfigAsync(IDocument input, IExecutionContext context, IMetadata values) { string content = values.GetString(Content); return(content == null ? input.Yield() : input.Clone(await context.GetContentProviderAsync(content, values.GetString(MediaType))).Yield()); }
protected override async Task <IEnumerable <IDocument> > ExecuteInputAsync(IDocument input, IExecutionContext context) { var metadata = await _getMetadata(input, context); return(metadata == null ? input.Yield() : input.Clone(metadata).Yield()); }
public static async Task <IDocument> CloneOrCreateDocumentAsync( this IExecutionContext context, IDocument document, IEnumerable <KeyValuePair <string, object> > items, string content, string mediaType = null) => document?.Clone(items, await context.GetContentProviderAsync(content, mediaType)) ?? context.CreateDocument(items, await context.GetContentProviderAsync(content, mediaType));
public static IDocument CloneOrCreateDocument( this IExecutionContext context, IDocument document, IEnumerable <KeyValuePair <string, object> > items, Stream stream, string mediaType = null) => document?.Clone(items, context.GetContentProvider(stream, mediaType)) ?? context.CreateDocument(items, context.GetContentProvider(stream, mediaType));
private static IModule[] GetTopLevelIndexModules(IDocument archiveDoc) => new IModule[] { new ReplaceDocuments(Config.FromContext(ctx => archiveDoc.Clone(new MetadataItems { { Keys.Children, ctx.Inputs } }).Yield())), new AddTitle(), new SetDestination(Config.FromValue(archiveDoc.Destination.ChangeExtension(".html")), true) };
/// <inheritdoc /> protected override async Task <IEnumerable <IDocument> > ExecuteConfigAsync(IDocument input, IExecutionContext context, string value) { if (value == null) { value = string.Empty; } if (string.IsNullOrEmpty(_search)) { return(input.Clone(await context.GetContentProviderAsync(value)).Yield()); } string inputContent = await input.GetContentStringAsync(); string replaced = _isRegex ? Regex.Replace(inputContent, _search, value, _regexOptions) : value.Replace(_search, inputContent); return(input.Clone(await context.GetContentProviderAsync(replaced)).Yield()); }
public static IDocument CloneOrCreateDocument( this IExecutionContext context, IDocument document, NormalizedPath source, NormalizedPath destination, Stream stream, string mediaType = null) => document?.Clone(source, destination, context.GetContentProvider(stream, mediaType)) ?? context.CreateDocument(source, destination, context.GetContentProvider(stream, mediaType));
protected override IEnumerable<IDocument> Execute(object content, IDocument input, IExecutionContext context) { return new [] { content == null ? input : input.Clone(input.Content + content) }; }
protected override IDocument Execute(string content, IDocument input) { return input.Clone(content); }
protected override IDocument Execute(string content, IDocument input) { return input.Clone(new[] { new KeyValuePair<string, object>(_key, content) }); }