public string FilterOut(string text, TransformationData data, PreprocessedData preprocessedData) { var map = preprocessedData.TextMap; try { foreach (var element in elements) { var changes = new List<PreprocessingTextChange>(); text = element.Pattern.Replace(text, m => FilterEvaluator(m, element.Predicate, changes)); Preprocessor.AddChangesToBounds(map, changes, preprocessedData, PreprocessedTextType.FilteredOut); map.ApplyChanges(changes); } } catch (FilterPredicateException e) { data.ErrorList.Add(Markdown.GenerateError( e.Message, MessageClass.Error, "", 0, data)); } return text; }
public EMDocument(string path, TransformationData data) { LocalPath = path; TransformationData = data; preprocessedData = new PreprocessedData(this, data.ProcessedDocumentCache); publish = false; }
public int AddToErrorList(TransformationData data, string originalText) { var errorId = data.ErrorList.Count; data.ErrorList.Add(Markdown.GenerateError(Message, MessageClass.Error, originalText, errorId, data)); return errorId; }
public override void AppendHTML(StringBuilder builder, Stack<EMInclude> includesStack, TransformationData data) { builder.Append( Templates.Region.Render( Hash.FromAnonymousObject( new { regionParameters = RegionParam, regionContent = Elements.GetInnerHTML(includesStack, data), singleLine }))); }
public string Preprocess(string text, TransformationData transData, PreprocessedData data, string relativePathToLinkedFile = null, bool full = true) { var relPath = relativePathToLinkedFile ?? transData.CurrentFolderDetails.CurrentFolderFromMarkdownAsTopLeaf; text = Normalizer.Normalize(text, data.TextMap); text = OffensiveWordFilterHelper.CheckAndGenerateInfos(text, data.TextMap); text = EscapeChars(text, data.TextMap); text = DoCodeSpans(text, data.TextMap); text = data.Metadata.ParseMetadata(text, transData, data, full); text = filter.FilterOut(text, transData, data); text = data.Variables.ParseVariablesDefinition(text, relPath, transData, data.TextMap); data.ExcerptTextMap = new PreprocessedTextLocationMap(data.TextMap); text = data.Excerpts.ParseExcerpts(text, transData, data.TextMap); text = data.ReferenceLinks.Parse(text, data); text = CutoutComments(text, data); return text; }
private string ParseVariableDefinition(Match everyMatch, string relPath, TransformationData data) { var value = everyMatch.Groups["variableContent"].Value.Replace("<a name=\"MARKDOWNANCHORNOTUSEDELSEWHERE\"></a>", ""); Add(everyMatch.Groups["variableName"].Value.ToLower(), value, data, relPath); return ""; }
public static EMElement CreateRegion(EMElementOrigin origin, EMDocument doc, EMElement parent, TransformationData data, EMMarkdownTaggedElementMatch match, string regionParameters) { var content = new EMRegion(doc, origin, parent, match, regionParameters); content.Elements.Parse(0, Markdown.OutdentIfPossible(match.Content, content.Elements.TextMap), data); return content; }
public EMLocalFilePath(string userPath, EMDocument doc, TransformationData data, Func<string, string> outputFileNameConversion = null) { userPath = Preprocessor.UnescapeChars(userPath, true); if (userPath.StartsWith("%ROOT%")) { userPath = userPath.Replace("%ROOT%", "."); } if (outputFileNameConversion == null) { outputFileNameConversion = NoConversion; } var localized = data.CurrentFolderDetails.Language != "INT"; IsImage = ImageExtensionPattern.IsMatch(userPath); var sourceDocDir = GetDirectoryName(userPath, doc, data); var fileName = Path.GetFileName(userPath); absolutePath = GetAbsoluteFilePath(sourceDocDir, fileName, data, localized); dstRelative = localized ? Path.Combine( GetFolderTypeName(), sourceDocDir, data.CurrentFolderDetails.Language, outputFileNameConversion(Path.GetFileName(userPath))) : Path.Combine( GetFolderTypeName(), sourceDocDir, outputFileNameConversion(Path.GetFileName(userPath))); if (!File.Exists(absolutePath)) { if (localized) { absolutePath = GetAbsoluteFilePath(sourceDocDir, fileName, data, false); changedLanguage = File.Exists(absolutePath); } if (!localized || !changedLanguage) { throw new EMPathVerificationException( Language.Message( string.Format( "{0}FileNotFoundIn{1}INTDir", IsImage ? "Image" : "Attachment", data.CurrentFolderDetails.Language != "INT" ? "LanguageOr" : ""), absolutePath)); } dstRelative = Path.Combine( GetFolderTypeName(), sourceDocDir, outputFileNameConversion(Path.GetFileName(userPath))); } }
private static EMElement CreateDecoration(IMatch match, EMDocument doc, EMElementOrigin origin, EMElement parent, TransformationData data) { var decorationMatch = match as EMDecorationMatch; var element = new EMDecorationElement(doc, origin, parent, decorationMatch.Type); element.Content.Parse(decorationMatch.ContentStart, decorationMatch.Content, data); return element; }
public override void AppendHTML(StringBuilder builder, Stack<EMInclude> includesStack, TransformationData data) { builder.Append(Templates.CustomTag.Render(Hash.FromAnonymousObject( new { tagName = name, attributesList = attributesString, content = Elements.GetInnerHTML(includesStack, data) }))); }
private static EMHeader CreateFromSetextMatch(Match match, EMDocument doc, EMElementOrigin origin, EMElement parent, TransformationData data) { var headerText = match.Groups[2].Value; var level = match.Groups[3].Value.StartsWith("=") ? 1 : 2; var isOptional = string.IsNullOrWhiteSpace(match.Groups[1].Value); headerText = Markdown.Unescape(data.Markdown.RunSpanGamut(headerText, data)); return new EMHeader(doc, origin, parent, level, headerText, isOptional); }
public static EMErrorElement Create( EMDocument doc, EMElementOrigin origin, EMElement parent, TransformationData data, string messageId, params string[] messageArgs) { return new EMErrorElement(doc, origin, parent, new EMReadingMessage(MessageClass.Error, messageId, messageArgs), data); }
public void AddToErrorListAndAppend(StringBuilder builder, TransformationData data, string originalText) { var errorId = AddToErrorList(data, originalText); if (data.Markdown.ThisIsPreview) { builder.Append( Templates.ErrorHighlight.Render( Hash.FromAnonymousObject(new { errorText = originalText, errorId }))); } }
public override void AppendHTML(StringBuilder builder, Stack<EMInclude> includesStack, TransformationData data) { try { builder.Append(path.GetPath(data).Replace("\\", "/")); } catch (EMPathVerificationException e) { e.AddToErrorListAndAppend(builder, data, Origin.Text); } }
public override void AppendHTML(StringBuilder builder, Stack<EMInclude> includesStack, TransformationData data) { var content = Elements.GetInnerHTML(includesStack, data); content = NewlinePattern.Replace(content, " "); // These leading spaces screw with <pre> content, so we need to fix that: content = PreTagPattern.Replace(content, BlockQuotePreLeadingSpacesFix); builder.Append(Templates.Blockquote.Render(Hash.FromAnonymousObject(new { value = content }))); }
public static void ParseElements( TransformationData data, EMDocument doc, EMElement parent, string text, IParser parser, Action<EMElement> elementEmitter) { var fragments = new List<TextFragment> { new TextFragment(0, text) }; ParseElements(data, doc, parent, fragments, parser, elementEmitter); }
private static EMElement CreateItem(EMListType type, EMDocument doc, Match match, EMElementOrigin origin, EMElement parent, TransformationData data) { var itemGroup = match.Groups[4]; var item = new EMListItem(doc, origin, parent, type); // adding offset to text map item.Elements.TextMap.ApplyChanges(new List<PreprocessingTextChange>() { new PreprocessingTextChange(0, itemGroup.Index - match.Index, 0) }); item.Elements.Parse(0, Markdown.Outdent(itemGroup.Value, item.Elements.TextMap), data); return item; }
public static void ParseElements( TransformationData data, EMDocument doc, EMElement parent, List<TextFragment> fragments, List<IParser> parsers, Action<EMElement> elementEmitter) { foreach (var parser in parsers) { ParseElements(data, doc, parent, fragments, parser, elementEmitter); } }
public static EMElement CreateFromText(string text, EMDocument doc, EMElementOrigin origin, EMElement parent, TransformationData data, bool imageLink = false) { try { var path = EMPathProvider.CreatePath(text, doc, data); return new EMRelativeLink(doc, origin, parent, path); } catch (EMPathVerificationException e) { return new EMErrorElement(doc, origin, parent, e.AddToErrorList(data, origin.Text)); } }
public override void Parse(List<TextFragment> fragments, TransformationData data) { ParseElements(data, fragments, new EMMarkdownAndHTMLTagsParser(GetLocation, true)); ParseElements(data, fragments, new EMSpanParser(GetLocation)); foreach (var fragment in fragments) { var formattedText = new EMFormattedText(Document, new EMElementOrigin(fragment.Start, fragment.Text), this); formattedText.Parse(fragment.Text, data); Add(formattedText); } }
public override void Parse(List<TextFragment> fragments, TransformationData data) { ParseElements(data, fragments, new EMMarkdownAndHTMLTagsParser(GetLocation)); ParseElements(data, fragments, EMHeader.GetParser()); ParseElements(data, fragments, EMInclude.GetParser()); ParseElements(data, fragments, EMTOCInline.GetParser()); ParseElements(data, fragments, EMBookmark.GetParser()); ParseElements(data, fragments, EMHorizontalRule.GetParser()); ParseElements(data, fragments, EMList.GetParser()); ParseElements(data, fragments, EMTable.GetParser()); ParseElements(data, fragments, EMCodeBlock.GetParser()); ParseElements(data, fragments, EMBlockQuotes.GetParser()); ParseElements(data, fragments, EMParagraph.GetParser()); }
public override EMElement Create(IMatch match, EMDocument doc, EMElementOrigin origin, EMElement parent, TransformationData data) { if (match is EMBracketedImagesAndLinksMatch) { return CreateBracketed(match, doc, origin, parent, data); } if (match is EMDecorationMatch) { return CreateDecoration(match, doc, origin, parent, data); } throw new InvalidOperationException("Should not happend!"); }
private static EMElement Create(Match match, EMDocument doc, EMElementOrigin origin, EMElement parent, TransformationData data) { var bqTextGroup = match.Groups[1]; var bqText = bqTextGroup.Value; bqText = Regex.Replace(bqText, @"^[ ]*>[ ]?", "", RegexOptions.Multiline); // trim one level of quoting bqText = Regex.Replace(bqText, @"^[ ]+$", "", RegexOptions.Multiline); // trim whitespace-only lines var bq = new EMBlockQuotes(doc, origin, parent); bq.Elements.Parse(origin.Start + bqTextGroup.Index, bqText, data); return bq; }
private static EMHeader CreateFromAtxMatch(Match match, EMDocument doc, EMElementOrigin origin, EMElement parent, TransformationData data) { var headerText = match.Groups[3].Value; if (headerText.Contains("ifndef") || headerText.Contains("endif")) { return null; } var level = match.Groups[1].Value.Length; var isOptional = string.IsNullOrWhiteSpace(match.Groups[2].Value); headerText = Markdown.Unescape(data.Markdown.RunSpanGamut(headerText, data)); return new EMHeader(doc, origin, parent, level, headerText, isOptional); }
public static EMElements ExcerptLazyParser(EMDocument doc, EMElement parent, string content, TransformationData data) { content = Preprocessor.CutoutComments(content, null); var elements = new EMElements(doc, new EMElementOrigin(0, content), parent); var previousCurrentFolder = data.CurrentFolderDetails.CurrentFolderFromMarkdownAsTopLeaf; var newCurrentFolder = doc.GetAbsoluteMarkdownPath(); data.CurrentFolderDetails.CurrentFolderFromMarkdownAsTopLeaf = newCurrentFolder; elements.Parse(content, data); data.CurrentFolderDetails.CurrentFolderFromMarkdownAsTopLeaf = previousCurrentFolder; return elements; }
public void Add(string name, string content, TransformationData data, string variableFileFolderName = null) { if (!string.IsNullOrWhiteSpace(variableFileFolderName)) { content = Markdown.ProcessRelativePaths(content, variableFileFolderName); } if (variableMap.ContainsKey(name)) { data.ErrorList.Add( new ErrorDetail(Language.Message("VariableRedefinition", name), MessageClass.Info, "", "", 0, 0) ); } else { variableMap.Add(name, content); } }
public static EMPathProvider CreatePath(string userPath, EMDocument currentDocument, TransformationData data) { if (EMEMailPath.Verify(userPath)) { return new EMEMailPath(userPath); } if (EMExternalPath.Verify(userPath)) { return new EMExternalPath(userPath); } if (EMLocalFilePath.Verify(userPath)) { return new EMLocalFilePath(userPath, currentDocument, data); } return new EMLocalDocumentPath(userPath, currentDocument, data); }
private static EMElement CreateBracketed( IMatch match, EMDocument doc, EMElementOrigin origin, EMElement parent, TransformationData data) { var taggedMatch = match as EMBracketedImagesAndLinksMatch; // Check if image. if (taggedMatch.Text.StartsWith("!") && !string.IsNullOrWhiteSpace(taggedMatch.Parameters)) { EMElement outElement = null; var fragments = new List<TextFragment>() { new TextFragment(origin.Start, match.Text) }; EMParsingHelper.ParseElements( data, doc, parent, fragments, EMImage.GetParser(), element => { outElement = element; }); if (outElement == null) { string imageError = "Could not find image in given text: " + origin.Text; throw new InvalidOperationException(imageError); } return outElement; } // Check if shortcut ref if (string.IsNullOrWhiteSpace(taggedMatch.Parameters)) { return EMLink.CreateFromAnchorRefShortcut( EMLink.AnchorRefShortcut.Match(taggedMatch.Text), doc, origin, parent, data); } // If not an image and not a shortcut link, then must have been other link. // Parse span content for internal elements. var span = new EMSpanElements(doc, origin, parent); span.Parse(taggedMatch.ContentStart, taggedMatch.Content, data); // Check if ref link return taggedMatch.Parameters.StartsWith("[") ? EMLink.CreateFromAnchorRef(doc, origin, parent, data, span, taggedMatch.Parameters) : EMLink.CreateFromInline(doc, origin, parent, data, span, taggedMatch.Parameters); }
public override EMElement Create(IMatch match, EMDocument doc, EMElementOrigin origin, EMElement parent, TransformationData data) { if (match is EMRawHTMLMatch) { var htmlMatch = match as EMRawHTMLMatch; if (htmlMatch.Name.ToLower() == "code") { return new EMCodeBlock(doc, origin, parent, htmlMatch.Content, true); } var element = new EMRawHTML(doc, origin, parent, htmlMatch.Name, htmlMatch.AttributesString); element.Elements.Parse(Markdown.Outdent(htmlMatch.Content, element.Elements.TextMap), data); return element; } if (match is EMMarkdownTaggedElementMatch) { var markdownMatch = match as EMMarkdownTaggedElementMatch; switch (markdownMatch.Name.ToLower()) { case "region": return EMRegion.CreateRegion(origin, doc, parent, data, markdownMatch, markdownMatch.Parameters); case "include": return EMInclude.CreateFromText(markdownMatch.Text, doc, origin, parent, data); case "include_files": return EMInclude.CreateIncludeFilesFromText(markdownMatch.Text, doc, origin, parent, data); case "relative": return EMRelativeLink.CreateFromText(markdownMatch.Parameters, doc, origin, parent, data); case "relative_img": return EMRelativeLink.CreateFromText(markdownMatch.Parameters, doc, origin, parent, data, true); case "object": return EMObject.CreateFromText(markdownMatch.Parameters, markdownMatch, doc, origin, parent, data); default: return EMErrorElement.Create(doc, origin, parent, data, "UnsupportedTaggedMarkdownElement"); } } return EMErrorElement.Create(doc, origin, parent, data, "UnknownMatchTypeForTaggedElementsParser"); }
public static EMObjectParam CreateParam(EMElementOrigin origin, EMDocument doc, EMElement parent, TransformationData data, EMMarkdownTaggedElementMatch match, string paramName, string paramIndentation) { var content = new EMObjectParam(doc, origin, parent, match, paramName); var text = Preprocessor.Replace( new Regex( "^" + Regex.Escape(paramIndentation), RegexOptions.Multiline), content.Elements.Origin.Text, "", content.Elements.TextMap); text = Preprocessor.Trim(text, '\n', content.Elements.TextMap); text = Markdown.OutdentIfPossible(text, content.Elements.TextMap); content.Elements.Parse(0, text, data); return content; }
/** * Adds an entry to the queue with predefined transformation time. This is a re-entry method, so we don't want to check for * duplicate data this time around in the queue. */ public bool Add(ulong time, TransformationData tData, bool inProgress = false) { this.CreateQueueIfUndefined(); this.queue.Add(new TransformationJob(time, tData, inProgress)); return(true); }
public abstract void Parse(List <TextFragment> fragments, TransformationData data);
public EMLocalDocumentPath(string userPath, EMDocument currentDocument, TransformationData data) { userPath = Preprocessor.Preprocessor.UnescapeChars(userPath, true); if (userPath.StartsWith("%ROOT%")) { userPath = userPath.Replace("%ROOT%", "."); } this.currentDocument = currentDocument; var match = DocumentPathPattern.Match(userPath); if (!match.Success) { throw new EMPathVerificationException(Language.Message("InvalidLocalDocumentPath", userPath)); } DocumentPath = match.Groups["path"].Value; changedLanguage = false; if (string.IsNullOrWhiteSpace(DocumentPath)) { DocumentPath = currentDocument.LocalPath; } else { DirectoryInfo docDir; try { docDir = new DirectoryInfo(Path.Combine(data.CurrentFolderDetails.AbsoluteMarkdownPath, DocumentPath)); } catch (Exception e) { if (e is NotSupportedException || e is ArgumentException) { throw new EMPathVerificationException(Language.Message("InvalidLocalDocumentPath", userPath)); } throw; } if (!docDir.Exists) { throw new EMPathVerificationException(Language.Message("BadLinkOrMissingMarkdownFileForLink", DocumentPath)); } var docFiles = docDir.GetFiles(string.Format("*.{0}.udn", data.CurrentFolderDetails.Language)); if (docFiles.Length == 0) { if (data.CurrentFolderDetails.Language != "INT") { docFiles = docDir.GetFiles("*.INT.udn"); changedLanguage = docFiles.Length != 0; } if (data.CurrentFolderDetails.Language == "INT" || !ChangedLanguage) { throw new EMPathVerificationException(Language.Message("BadLinkOrMissingMarkdownFileForLink", DocumentPath)); } } DocumentPath = docFiles[0].FullName; } BookmarkName = match.Groups["bookmark"].Value; if (string.IsNullOrWhiteSpace(BookmarkName)) { BookmarkName = null; } }
public ProcessedDocumentCache(string path, TransformationData data) { TransformationData = data; currentFileDocument = new EMDocument(path, data); }
public void FlattenInternalLinks(TransformationData data) { if (Data == null) { return; } var bookmarks = new Dictionary <string, EMBookmark>(); Data.GetElements <EMBookmark>().ForEach((bookmark) => { if (bookmarks.ContainsKey(bookmark.UniqueKey)) { var errorId = data.ErrorList.Count; data.ErrorList.Add( Markdown.GenerateError( Language.Message("ConflictingBookmarkNameOrHeaderId", bookmark.UniqueKey), MessageClass.Info, bookmark.Origin.Text, errorId, data)); return; } bookmarks.Add(bookmark.UniqueKey, bookmark); }); var inclusions = new Dictionary <string, EMInclude>(); Data.GetElements <EMInclude>().ForEach(e => { if (!e.Excerpt.IsDocumentExcerpt) { return; } e.AddHashedPathBookmarkToOutput(); var inclusionPath = e.Excerpt.Document.LocalPath.ToLower(); if (!inclusions.ContainsKey(inclusionPath)) { inclusions.Add(inclusionPath, e); } }); foreach ( var link in Data.GetElements( e => (e is EMLink) && (e as EMLink).Path is EMLocalDocumentPath).Cast <EMLink>()) { var path = link.Path as EMLocalDocumentPath; var id = path.BookmarkName; if ((path.IsBookmark && (path.DocumentPath != path.currentDocument.LocalPath || !bookmarks.ContainsKey(id))) || (!path.IsBookmark && !inclusions.ContainsKey(path.DocumentPath.ToLower()))) { if (data.NonDynamicHTMLOutput) { link.ConvertToJustTextOutput(); } } else { link.ConvertToInternal(); } } }
public static EMElements ExcerptLazyParser(EMDocument doc, EMElement parent, string content, TransformationData data) { content = Preprocessor.CutoutComments(content, null); var elements = new EMElements(doc, new EMElementOrigin(0, content), parent); var previousCurrentFolder = data.CurrentFolderDetails.CurrentFolderFromMarkdownAsTopLeaf; var newCurrentFolder = doc.GetAbsoluteMarkdownPath(); data.CurrentFolderDetails.CurrentFolderFromMarkdownAsTopLeaf = newCurrentFolder; elements.Parse(content, data); data.CurrentFolderDetails.CurrentFolderFromMarkdownAsTopLeaf = previousCurrentFolder; return(elements); }
public override void AppendHTML(StringBuilder builder, Stack <EMInclude> includesStack, TransformationData data) { builder.Append(Content); }
public override void AppendHTML(StringBuilder builder, Stack <EMInclude> includesStack, TransformationData data) { foreach (var element in elements) { element.Value.AppendHTML(builder, includesStack, data); } }
public static EMPathProvider CreatePath(string userPath, EMDocument currentDocument, TransformationData data) { if (EMEMailPath.Verify(userPath)) { return(new EMEMailPath(userPath)); } if (EMExternalPath.Verify(userPath)) { return(new EMExternalPath(userPath)); } if (EMLocalFilePath.Verify(userPath)) { return(new EMLocalFilePath(userPath, currentDocument, data)); } return(new EMLocalDocumentPath(userPath, currentDocument, data)); }
public void AppendHTML(StringBuilder builder, Stack <EMInclude> includesStack, TransformationData data) { var cells = new StringBuilder(); foreach (var cell in Cells) { cell.AppendHTML(cells, includesStack, data); } builder.Append(Templates.TableRow.Render( Hash.FromAnonymousObject(new { hasError = HasError, errorId = ErrorId, cells = cells.ToString() }))); }
public override void AppendHTML(StringBuilder builder, Stack <EMInclude> includesStack, TransformationData data) { var headers = new StringBuilder(); if (tableHeaderRows != null) { foreach (var headerRow in tableHeaderRows) { headerRow.AppendHTML(headers, includesStack, data); } } var rows = new StringBuilder(); foreach (var row in tableRows) { row.AppendHTML(rows, includesStack, data); } builder.Append(Templates.Table.Render(Hash.FromAnonymousObject( new { caption = optionalCaption, columnAlignments = tableColumnAlignments, headers = tableHeaderRows != null ? headers.ToString() : null, rows = rows.ToString() }))); }
public void Parse(string text, TransformationData data) { Parse(0, text, data); }
public override void AppendHTML(StringBuilder builder, Stack <EMInclude> includesStack, TransformationData data) { if (includesStack.Count > 0 && !includesStack.First().IncludeTOC) { return; } var isLocalTOC = linkedDocument == Document.TransformationData.Document; builder.Append(RenderTOC( startLevel, endLevel, string.IsNullOrWhiteSpace(path) ? "" : Path.Combine( data.CurrentFolderDetails.RelativeHTMLPath, data.CurrentFolderDetails.Language, path, "index.html"), !isLocalTOC)); }
public EMElement Create(IMatch match, EMDocument doc, EMElementOrigin origin, EMElement parent, TransformationData data) { return(elementCreator((TMatch)match, doc, origin, parent, data)); }
private static List <TableRowInformation> GetHeaders(EMDocument doc, EMElementOrigin origin, EMElement parent, TransformationData data, int headerOffset, string tableHeader, out bool useRowHeader) { // Add headers // May be multiple lines, may have columns spanning // May also have no header if we are intending the 1st column to be the header var map = new PreprocessedTextLocationMap(); tableHeader = RemoveTrailingWhitespaceAndNewLines(tableHeader, map); List <TableRowInformation> templateHeaderRows = null; useRowHeader = true; if (!String.IsNullOrWhiteSpace(tableHeader)) { templateHeaderRows = new List <TableRowInformation>(); var headerRowOffset = 0; var headerRows = Regex.Split(tableHeader, @"\n"); foreach (var headerRow in headerRows) { var count = 0; var headerColumns = Regex.Matches(headerRow, @"[ ]?([^\|]+)[ ]?([\|]*)"); var row = new TableRowInformation(); foreach (Match headerColumn in headerColumns) { var cellGroup = headerColumn.Groups[1]; var columnSpanLength = 1; if (Regex.Match(headerColumn.Groups[2].Value, @"(\|{2,})").Success) { columnSpanLength = Regex.Match(headerColumn.Groups[2].Value, @"(\|{2,})").Length; } var cell = new TableCellInformation(doc, new EMElementOrigin(headerOffset + map.GetOriginalPosition(headerRowOffset + cellGroup.Index, PositionRounding.Down), cellGroup.Value), parent, data, columnSpanLength, null, true); if (count == 0) { useRowHeader = !Regex.Match(cell.ToString(), @"(\S)").Success; } count++; row.Cells.Add(cell); } headerRowOffset += headerRow.Length + 1; templateHeaderRows.Add(row); } } return(templateHeaderRows); }
private static string ParseExcerpt(Match match, Dictionary <string, ExcerptInfo> excerptsInfos, TransformationData data, List <PreprocessingTextChange> changes) { var name = match.Groups["name"].Value.ToLower(); var contentGroup = match.Groups["content"]; var content = contentGroup.Value; content = ExcerptBlock.Replace(content, m => ParseExcerpt(m, excerptsInfos, data, null)); content = ExcerptInline.Replace(content, m => ParseExcerpt(m, excerptsInfos, data, null)); if (excerptsInfos.ContainsKey(name)) { excerptsInfos[name].Content.Append("\n" + content); } else { excerptsInfos.Add(name, new ExcerptInfo(match.Index, contentGroup.Index - match.Index, content)); } if (changes != null) { changes.Add(PreprocessingTextChange.CreateRemove(match.Groups["prefix"])); changes.Add(PreprocessingTextChange.CreateRemove(match.Groups["postfix"])); } return(content); }
public override void AppendHTML(System.Text.StringBuilder builder, System.Collections.Generic.Stack <EMInclude> includesStack, TransformationData data) { // write nothing }
protected void ParseElements(TransformationData data, List <TextFragment> fragments, IParser parser) { EMParsingHelper.ParseElements(data, Document, this, fragments, parser, Add); }
public EMTable(EMDocument doc, EMElementOrigin origin, EMElement parent, Match match, TransformationData data) : base(doc, origin, parent) { var tableAlignment = RemoveTrailingWhitespaceAndNewLines(match.Groups[3].Value, null); bool useRowHeader; optionalCaption = data.Markdown.RunSpanGamut(GetOptionalCaption(match.Groups[0].Value), data); tableHeaderRows = GetHeaders(doc, origin, this, data, match.Groups[2].Index - match.Index, match.Groups[2].Value, out useRowHeader); tableColumnAlignments = new List <Hash>(); tableRows = GetRows(this, data, match.Groups[5].Index - match.Index, match.Groups[5].Value, GetAlignments(tableAlignment, tableColumnAlignments), useRowHeader, !String.IsNullOrWhiteSpace(match.Groups[2].Value)); }
private static EMElement CreateTable(Match match, EMDocument doc, EMElementOrigin origin, EMElement parent, TransformationData data) { return(new EMTable(doc, origin, parent, match, data)); }
public EMExcerpt(EMDocument doc, int originPosition, int contentStart, string content, TransformationData data, bool isDocumentExcerpt) : base(doc, new EMElementOrigin(originPosition + contentStart, content), null) { this.IsDocumentExcerpt = isDocumentExcerpt; lazyLoadingFunction = () => ExcerptLazyParser(doc, this, content, data); }
protected void ParseElements(TransformationData data, List <TextFragment> fragments, IEnumerable <IParser> parsers) { ParseElements(data, Document, fragments, parsers); }
public void Parse(string content, TransformationData data) { Content = Markdown.Unescape(data.Markdown.RunSpanGamut(content, data)); }
/** * Gets the transformation time from world time */ private static ulong CalculateTransformationTimeAsWorldTime(TransformationData tData) { ulong worldTime = GameManager.Instance.World.worldTime; return(worldTime + (ulong)tData.transformationTime); }
private static List <TableRowInformation> GetRows( EMElement parent, TransformationData data, int tableDataOffset, string tableData, string[] alignments, bool useRowHeader, bool hasHeader) { // Add body data var tableRows = new List <TableRowInformation>(); var map = new PreprocessedTextLocationMap(); tableData = RemoveTrailingWhitespaceAndNewLines(tableData, map); var dataRows = Regex.Split(tableData, @"\n"); var rowOffset = 0; for (var i = 0; i < dataRows.Count(); ++i) { var dataRow = dataRows[i]; // Parse table into List of List of CellInformation var count = 0; var dataColumns = Regex.Matches(dataRow, @"([^\|]+)([\|]*)"); var tableRow = new TableRowInformation(); // Check to see if someone has left an empty row incorrectly formatted, which we can fix. if (dataColumns.Count == 0) { var fixedDataRow = dataRow; for (var j = dataRow.Length; j < alignments.Length + 1; ++j) { fixedDataRow += '|'; } fixedDataRow = fixedDataRow.Insert(1, " "); dataColumns = Regex.Matches(fixedDataRow, @"([^\|]+)([\|]*)"); } foreach (Match dataColumn in dataColumns) { int addToOffset; var cell = Normalizer.LeadingWhitespaceRemove(dataColumn.Groups[1].Value, out addToOffset); cell = Normalizer.TrailingWhitespaceRemove(cell); var columnSpanLength = 1; var isRowHeader = (count == 0 && useRowHeader && dataColumns.Count > 1) || (dataColumns.Count == 1 && i == 0 && !hasHeader); if (Regex.Match(dataColumn.Groups[2].Value, @"(\|{2,})").Success) { columnSpanLength = Regex.Match(dataColumn.Groups[2].Value, @"(\|{2,})").Length; } // @UE3 ensure that the index into alignments is not greater than the amount expected. (Users may accidentally add extra || to lines) string alignment = null; if (count >= alignments.Length) { // Report only 1 error per row per run to avoid duplicates if (!tableRow.HasError) { var errorCount = data.ErrorList.Count; tableRow.ErrorId = errorCount; tableRow.HasError = true; data.ErrorList.Add( Markdown.GenerateError( Language.Message( "MoreColumnsThanAllignmentsInOneOfTheTableRowsColumnsIgnored", Markdown.Unescape(dataRows[i])), MessageClass.Error, Markdown.Unescape(dataRows[i]), errorCount, data)); } } else { alignment = alignments[count]; } var cellInformation = (cell.Trim() != "^") ? new TableCellInformation( parent.Document, new EMElementOrigin(tableDataOffset + map.GetOriginalPosition(addToOffset + rowOffset + dataColumn.Groups[1].Index, PositionRounding.Down), cell), parent, data, columnSpanLength, alignment, isRowHeader) : new TableCellInformation(columnSpanLength, alignment, isRowHeader, false, 1, true); tableRow.Cells.Add(cellInformation); // Make parsing table easier later, if ColumnSpan > 1 create a blank column for each over one for (var dummyColumnCount = 1; dummyColumnCount < columnSpanLength; ++dummyColumnCount) { tableRow.Cells.Add(new TableCellInformation(0)); } // @UE3 this was not in original specification, handles correct alignment of a subsequent column after a long column. count += columnSpanLength; } // If count is zero check that someone has just not placed a space in the first column indicating it should be empty. if (count < alignments.Length) { var errorCount = data.ErrorList.Count; tableRow.ErrorId = errorCount; tableRow.HasError = true; data.ErrorList.Add( Markdown.GenerateError( Language.Message( "LessColumnsThanExpectedInOneOfTheTableRowsEmptyCellsInserted", Markdown.Unescape(dataRows[i])), MessageClass.Error, Markdown.Unescape(dataRows[i]), errorCount, data)); } // If count is less than total expected for a rows data add dummy column and raise error for (var dummyColumnCount = count; dummyColumnCount < alignments.Length; ++dummyColumnCount) { tableRow.Cells.Add(new TableCellInformation(1, null, false, true)); } tableRows.Add(tableRow); rowOffset += dataRow.Length + 1; } // Now work out rowspans based on Content and character ^ // Work down rows in columns for (var columnNumber = 0; columnNumber < alignments.Length; ++columnNumber) { var firstNonSpanRow = -1; for (var rowNumber = 0; rowNumber < tableRows.Count; ++rowNumber) { if (tableRows[rowNumber].Cells[columnNumber].IsRowSpanColumn) //Found a rowspan column { if (rowNumber == 0) { var errorCount = data.ErrorList.Count; tableRows[rowNumber].ErrorId = errorCount; tableRows[rowNumber].HasError = true; data.ErrorList.Add( Markdown.GenerateError( Language.Message( "ColumnCannotBeSetToSpanWithSpecialSymbolInTheFirstRowOfATable", dataRows[0]), MessageClass.Error, dataRows[0], errorCount, data)); } else { if (firstNonSpanRow < 0) { //is this the first detected row for this span? firstNonSpanRow = rowNumber - 1; //Row span above this 1 now should include itself tableRows[firstNonSpanRow].Cells[columnNumber].RowSpanCount = 1; } //Increment the Row above first_row detected by 1 tableRows[firstNonSpanRow].Cells[columnNumber].RowSpanCount += 1; } } else if (firstNonSpanRow >= 0) { //This row is not a rowspan but we had one previously so clear for any other rowspans in the column firstNonSpanRow = -1; } } } return(tableRows); }
public static EMObjectParam CreateParam(EMElementOrigin origin, EMDocument doc, EMElement parent, TransformationData data, EMMarkdownTaggedElementMatch match, string paramName, string paramIndentation) { var content = new EMObjectParam(doc, origin, parent, match, paramName); var text = Preprocessor.Replace( new Regex( "^" + Regex.Escape(paramIndentation), RegexOptions.Multiline), content.Elements.Origin.Text, "", content.Elements.TextMap); text = Preprocessor.Trim(text, '\n', content.Elements.TextMap); text = Markdown.OutdentIfPossible(text, content.Elements.TextMap); content.Elements.Parse(0, text, data); return(content); }
public static string GetSymbolDescriptionAndCatchExceptionIntoMarkdownErrors(string path, string originalUserEntry, DescriptionType descriptionType, TransformationData transformationDataForThisRun, Markdown parser, HashSet <string> foundSymbolPaths = null) { var outputText = ""; var isError = false; var isInfo = false; var errorId = 0; try { var match = SymbolPathPattern.Match(path); if (!match.Success) { throw new InvalidDoxygenPath(path); } var symbolPath = match.Groups["symbolPath"].Value; var overloadSpec = match.Groups["overloadSpecification"].Value; var symbol = DoxygenDbCache.GetSymbolFromPath(symbolPath); if (foundSymbolPaths != null) { foundSymbolPaths.Add(symbolPath); } if (symbol.IsOverloadedMember) { if (string.IsNullOrWhiteSpace(overloadSpec)) { throw new DoxygenAmbiguousSymbolException(path, symbol.GetOverloadSpecificationOptions()); } outputText = symbol.GetSymbolDescription(descriptionType, overloadSpec); } else { outputText = symbol.GetSymbolDescription(descriptionType); } } catch (Exception e) { errorId = transformationDataForThisRun.ErrorList.Count; transformationDataForThisRun.ErrorList.Add( Markdown.GenerateError( Language.Message("DoxygenQueryError", e.Message), MessageClass.Error, originalUserEntry, errorId, transformationDataForThisRun)); isError = true; // rethrowing if not known exception if (!(e is InvalidDoxygenPath) && !(e is SymbolNotFoundInDoxygenXmlFile) && !(e is DoxygenAmbiguousSymbolException)) { throw; } } if (parser.ThisIsPreview && (isInfo || isError)) { return(Templates.ErrorHighlight.Render(Hash.FromAnonymousObject( new { errorId = errorId, errorText = outputText }))); } return(outputText); }
public abstract string GetPath(TransformationData data);
public override void AppendHTML(StringBuilder builder, Stack <EMInclude> includesStack, TransformationData data) { builder.Append(Elements.GetInnerHTML(includesStack, data)); }
public void AppendHTML(StringBuilder builder, Stack <EMInclude> includesStack, TransformationData data) { builder.Append( Templates.TableCell.Render( Hash.FromAnonymousObject( new { hasContent = (Content != null), isRowHeader = IsRowHeader, rowSpanCount = RowSpanCount, colSpanCount = ColSpanCount, alignment = Alignment, content = (Content != null) ? Content.GetInnerHTML(includesStack, data) : null }))); }