public static void ParseElements(TransformationData data, EMDocument doc, EMElement parent, List <TextFragment> fragments, IParser parser, Action <EMElement> elementEmitter)
{
var newFragments = new List <TextFragment>();
foreach (var fragment in fragments)
{
var origins = new List <ITextFragment>();
try
{
foreach (var match in parser.TextMatches(fragment.Text))
{
var elementOrigin = new EMElementOrigin(fragment.Start + match.Index, match.Text);
try
{
elementEmitter(parser.Create(match, doc, elementOrigin, parent, data));
origins.Add(elementOrigin);
}
catch (EMSkipParsingException)
{
}
}
newFragments.AddRange(SplitFragment(fragment, origins));
}
catch (EMParsingErrorException e)
{
data.ErrorList.Add(new ErrorDetail(e.Message, MessageClass.Error, "", "", e.Line, e.Column, e.Path != data.Document.LocalPath ? e.Path : null));
}
}
fragments.Clear();
fragments.AddRange(newFragments);
}
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)));
}
}
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 void Reload()
{
FailWhenDisposed();
var text = FileHelper.SafeReadAllText(path);
document = new EMDocument(path, cache.TransformationData);
document.Parse(text, true, false);
}
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;
}
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 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 string GetDirectoryName(string userPath, EMDocument doc, TransformationData data)
{
var dir = Path.GetDirectoryName(userPath);
if (string.IsNullOrWhiteSpace(dir))
{
dir = FileHelper.GetRelativePath(
data.CurrentFolderDetails.AbsoluteMarkdownPath, Path.GetDirectoryName(doc.LocalPath));
}
return(dir);
}
public PreprocessedData(EMDocument document, ProcessedDocumentCache manager)
{
Excerpts = new ExcerptsManager(this);
Variables = new VariableManager(this);
Metadata = new MetadataManager(this);
ReferenceLinks = new ReferenceLinksManager(this);
TextMap = new PreprocessedTextLocationMap();
PreprocessedTextBounds = new List <PreprocessedTextBound>();
Document = document;
this.manager = manager;
}
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 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 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!");
}
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!");
}
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);
}
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"));
}
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 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 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 string ReplaceVariables(EMDocument doc, string text, TransformationData data, PreprocessedTextLocationMap map = null)
{
text = EMTOCInline.ConvertVariableLikeTOCInlines(text, map);
var stack = new Stack <Tuple <string, string> >();
var currentFile = new FileInfo(doc.LocalPath);
return(map == null
? InLineVariableOrMetadata.Replace(
text,
everyMatch =>
ParseInLineVariableOrMetadata(everyMatch, currentFile, currentFile, data, doc, stack))
: Preprocessor.Replace(
InLineVariableOrMetadata,
text,
everyMatch =>
ParseInLineVariableOrMetadata(everyMatch, currentFile, currentFile, data, doc, stack),
map));
}
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");
}
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);
}
protected virtual void Dispose(bool disposing)
{
if (disposed || !disposing)
{
return;
}
linkedFilesCacheLock.EnterReadLock();
try
{
foreach (var cacheElement in linkedFilesCache)
{
cacheElement.Value.Dispose();
}
currentFileDocument = null;
disposed = true;
}
finally
{
linkedFilesCacheLock.ExitReadLock();
}
}
public static void ParseElements(TransformationData data, EMDocument doc, EMElement parent, List<TextFragment> fragments, IParser parser, Action<EMElement> elementEmitter)
{
var newFragments = new List<TextFragment>();
foreach (var fragment in fragments)
{
var origins = new List<ITextFragment>();
try
{
foreach (var match in parser.TextMatches(fragment.Text))
{
var elementOrigin = new EMElementOrigin(fragment.Start + match.Index, match.Text);
try
{
elementEmitter(parser.Create(match, doc, elementOrigin, parent, data));
origins.Add(elementOrigin);
}
catch (EMSkipParsingException)
{
}
}
newFragments.AddRange(SplitFragment(fragment, origins));
}
catch (EMParsingErrorException e)
{
data.ErrorList.Add(new ErrorDetail(e.Message, MessageClass.Error, "", "", e.Line, e.Column, e.Path != data.Document.LocalPath ? e.Path : null));
}
}
fragments.Clear();
fragments.AddRange(newFragments);
}
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 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;
}
}
private string GetDirectoryName(string userPath, EMDocument doc, TransformationData data)
{
var dir = Path.GetDirectoryName(userPath);
if (string.IsNullOrWhiteSpace(dir))
{
dir = FileHelper.GetRelativePath(
data.CurrentFolderDetails.AbsoluteMarkdownPath, Path.GetDirectoryName(doc.LocalPath));
}
return dir;
}
public abstract EMElement Create(IMatch match, EMDocument doc, EMElementOrigin origin, EMElement parent, TransformationData data);
public abstract EMElement Create(IMatch match, EMDocument doc, EMElementOrigin origin, EMElement parent, TransformationData data);
public EMElement Create(IMatch match, EMDocument doc, EMElementOrigin origin, EMElement parent, TransformationData data)
{
return(elementCreator((TMatch)match, doc, origin, parent, data));
}
private string ParseInLineVariableOrMetadata(Match match, FileInfo currentFile, FileInfo originalScope, TransformationData data, EMDocument doc, Stack <Tuple <string, string> > visitedVariables)
{
var pathToLinkedFile = match.Groups["path"].Value;
var variableName = match.Groups["variableName"].Value.ToLower();
var originalString = match.Value;
string relativePathToLinkedFile = null;
var outString = "";
var isProblem = false;
var changedLanguage = false;
var errorId = 0;
var OnErrorStringToUseForMatch = originalString;
//ignore if the value is STOPPUBLISH STARTPUBLISH
if (variableName.Equals("STOPPUBLISH") || variableName.Equals("STARTPUBLISH") || originalString.ToUpper() == "%ROOT%" || VariableManager.IsKeywordToSkip(originalString))
{
return(originalString);
}
else
{
if (pathToLinkedFile.Equals("doxygen"))
{
var excerptName = ("doxygen:" + match.Groups["variableName"].Value).Replace(':', 'x');
if (!doc.Excerpts.Exists(excerptName))
{
var content =
DoxygenHelper.GetSymbolDescriptionAndCatchExceptionIntoMarkdownErrors(
match.Groups["variableName"].Value,
match.Value,
DoxygenHelper.DescriptionType.Full,
data,
data.Markdown,
data.FoundDoxygenSymbols).Trim();
content = Normalizer.Normalize(content, null);
doc.Excerpts.AddExcerpt(
excerptName, new EMExcerpt(doc, 0, 0, content, data, excerptName == ""));
}
return(string.Format("[INCLUDE:#{0}]", excerptName));
}
if (pathToLinkedFile.Equals("orig"))
{
currentFile = originalScope;
relativePathToLinkedFile = data.CurrentFolderDetails.CurrentFolderFromMarkdownAsTopLeaf;
}
else if (!String.IsNullOrWhiteSpace(pathToLinkedFile))
{
// Link other file and get metadata from there.
var languageForFile = data.CurrentFolderDetails.Language;
relativePathToLinkedFile = pathToLinkedFile;
var linkedFileDir = new DirectoryInfo(Path.Combine(Path.Combine(data.CurrentFolderDetails.AbsoluteMarkdownPath, pathToLinkedFile)));
if (!linkedFileDir.Exists || linkedFileDir.GetFiles(string.Format("*.{0}.udn", data.CurrentFolderDetails.Language)).Length == 0)
{
// if this is not an INT file check for the INT version.
if (data.CurrentFolderDetails.Language != "INT")
{
if (!linkedFileDir.Exists || linkedFileDir.GetFiles("*.INT.udn").Length == 0)
{
errorId = data.ErrorList.Count;
data.ErrorList.Add(
Markdown.GenerateError(
Language.Message(
"BadLinkOrMissingMarkdownFileAndNoINTFile", pathToLinkedFile, variableName),
MessageClass.Error,
Markdown.Unescape(OnErrorStringToUseForMatch),
errorId,
data));
isProblem = true;
}
else
{
// Found int file
languageForFile = "INT";
// Raise info so that now we are allowing missing linked files to still allow processing of the file if INT file is there
errorId = data.ErrorList.Count;
data.ErrorList.Add(
Markdown.GenerateError(
Language.Message(
"BadLinkOrMissingMarkdownFileINTUsed", pathToLinkedFile, variableName),
MessageClass.Info,
Markdown.Unescape(OnErrorStringToUseForMatch),
errorId,
data));
isProblem = true;
changedLanguage = true;
}
}
else
{
errorId = data.ErrorList.Count;
data.ErrorList.Add(
Markdown.GenerateError(
Language.Message("BadLinkOrMissingMarkdownFile", pathToLinkedFile, variableName),
MessageClass.Error,
Markdown.Unescape(OnErrorStringToUseForMatch),
errorId,
data));
isProblem = true;
outString = OnErrorStringToUseForMatch;
}
}
if (linkedFileDir.Exists && linkedFileDir.GetFiles(string.Format("*.{0}.udn", languageForFile)).Length > 0)
{
currentFile = linkedFileDir.GetFiles(string.Format("*.{0}.udn", languageForFile))[0];
}
}
// Cycle detection mechanism. First check if there was request for that variable in the visited stack.
var currentVisitedVariableTuple = new Tuple <string, string>(currentFile.FullName, variableName);
if (visitedVariables != null && visitedVariables.Contains(currentVisitedVariableTuple))
{
// cycle detected
visitedVariables.Push(currentVisitedVariableTuple);
string visitedVariablesMessage = string.Join(", ", visitedVariables.Select(
(v) =>
{
return(string.Format("[{0}, {1}]", v.Item1, v.Item2));
}));
visitedVariables.Pop();
data.ErrorList.Add(
Markdown.GenerateError(Language.Message("CycleDetectedInVariableRefs", visitedVariablesMessage), MessageClass.Error,
"", data.ErrorList.Count, data));
return("");
}
if (!data.ProcessedDocumentCache.TryGetLinkedFileVariable(currentFile, variableName, out outString))
{
if (doc.PerformStrictConversion())
{
//error
errorId = data.ErrorList.Count;
data.ErrorList.Add(
Markdown.GenerateError(
Language.Message("VariableOrMetadataNotFoundInFile", variableName, currentFile.FullName),
MessageClass.Error,
OnErrorStringToUseForMatch,
errorId,
data));
isProblem = true;
}
outString = OnErrorStringToUseForMatch.Replace("%", "%");
}
else
{
// If there was no request for this variable then push it.
visitedVariables.Push(currentVisitedVariableTuple);
outString = InLineVariableOrMetadata.Replace(
outString,
everyMatch =>
ParseInLineVariableOrMetadata(everyMatch, currentFile, originalScope, data, doc, visitedVariables));
// After parsing inner string pop visited variable from the stack.
visitedVariables.Pop();
}
if (changedLanguage)
{
//If we had to replace the language with INT then update the linkText to include link to image of flag
outString += Templates.ImageFrame.Render(
Hash.FromAnonymousObject(
new
{
imageClass = "languageinline",
imagePath = Path.Combine(
data.CurrentFolderDetails.RelativeHTMLPath,
"Include", "Images", "INT_flag.jpg")
}));
}
}
if (data.Markdown.ThisIsPreview && isProblem)
{
return(Templates.ErrorHighlight.Render(
Hash.FromAnonymousObject(
new
{
errorId = errorId,
errorText = outString
})));
}
return(outString);
}
public static List <PathElement> GetSuggestionList(EMDocument doc, string userPath, PathElementType options)
{
var list = new List <PathElement>();
var emptyInputPath = false;
if (string.IsNullOrWhiteSpace(userPath))
{
emptyInputPath = true;
userPath = "";
}
var langId = LangIdPattern.Match(Path.GetFileName(doc.LocalPath)).Groups["langId"].Value;
var m = RootKeywordPattern.Match(userPath);
userPath = m.Success
? userPath.Replace(m.Value, GetSourceDir(doc.LocalPath))
: Path.Combine(Path.GetDirectoryName(doc.LocalPath), userPath);
DirectoryInfo userDir;
try
{
userDir = new DirectoryInfo(userPath);
}
catch (Exception e)
{
if (e is ArgumentNullException || e is SecurityException || e is ArgumentException ||
e is PathTooLongException)
{
// ignore and output empty list
return(list);
}
throw;
}
if (userDir.Exists)
{
if ((options & (PathElementType.Image | PathElementType.Attachment | PathElementType.Folder)) > 0)
{
// File system infos.
var dirs = userDir.GetDirectories();
if (options.HasFlag(PathElementType.Image))
{
var imagesDirs = dirs.Where(d => d.Name.ToLower() == "images").ToArray();
if (imagesDirs.Length > 0)
{
list.AddRange(
imagesDirs[0].GetFiles().Select(f => new PathElement(f.Name, PathElementType.Image)));
}
}
if (options.HasFlag(PathElementType.Attachment))
{
var attachmentsDirs = dirs.Where(d => d.Name.ToLower() == "attachments").ToArray();
if (attachmentsDirs.Length > 0)
{
list.AddRange(
attachmentsDirs[0].GetFiles()
.Select(f => new PathElement(f.Name, PathElementType.Attachment)));
}
}
if (options.HasFlag(PathElementType.Folder))
{
if (emptyInputPath)
{
list.Add(new PathElement("%ROOT%", PathElementType.Folder));
}
list.AddRange(
dirs.Where(d => d.Name.ToLower() != "attachments" && d.Name.ToLower() != "images")
.Select(d => new PathElement(d.Name, PathElementType.Folder)));
}
}
if ((options & (PathElementType.Bookmark | PathElementType.Excerpt | PathElementType.Variable)) > 0)
{
var files = userDir.GetFiles(string.Format("*.{0}.udn", langId));
if (files.Length > 0)
{
var linkedDocument = files[0].FullName.Equals(doc.LocalPath, StringComparison.InvariantCultureIgnoreCase)
? doc
: doc.TransformationData.ProcessedDocumentCache.Get(files[0].FullName);
if (options.HasFlag(PathElementType.Bookmark) && emptyInputPath)
{
list.AddRange(linkedDocument.GetBookmarkKeys().Select(n => new PathElement(n, PathElementType.Bookmark)));
}
if (options.HasFlag(PathElementType.Excerpt))
{
list.AddRange(linkedDocument.GetExcerptNames().Select(n => new PathElement(n, PathElementType.Excerpt)));
}
if (options.HasFlag(PathElementType.Variable))
{
list.AddRange(linkedDocument.GetVariableNames().Select(n => new PathElement(n, PathElementType.Variable)));
}
}
}
}
return(list);
}
