protected override string GenerateContent(IDataContext context, string outputFolder)
{
var shortcutsXmlDoc = new XDocument();
var actionMapElement = new XElement("Keymap");
shortcutsXmlDoc.Add(actionMapElement);
XmlHelpers.AddAutoGenComment(shortcutsXmlDoc.Root);
const string menuPathLibId = "Menupath_by_ID";
var menuPathLibrary = XmlHelpers.CreateHmTopic(menuPathLibId);
const string accessIntroLibId = "AccessIntro_by_ID";
var accessIntroLibrary = XmlHelpers.CreateHmTopic(accessIntroLibId);
var actionManager = context.GetComponent <IActionManager>();
var productcatalogs = context.GetComponent <IPartCatalogSet>();
var actionParts = PartSelector.LeafsAndHides.SelectParts(
productcatalogs.Catalogs.SelectMany(catalog => catalog.GetPartsWithAttribute <ActionAttribute>().ToEnumerable()))
.ToList();
foreach (PartCatalogType actionPart in actionParts)
{
var attributes = actionPart.GetPartAttributes <ActionAttribute>();
if (attributes.Count == 0)
{
Assertion.Fail("{0} has no ActionAttribute", actionPart);
}
if (attributes.Count > 1)
{
Assertion.Fail("{0} has {1} ActionAttribute annotations. Only one annotation is supported.",
actionPart, attributes.Count);
}
PartCatalogAttribute attribute = attributes.GetItemAt(0);
var actionId =
(attribute.ArgumentsOptional[ActionAttribute.ActionAttribute_ActionId].GetStringValueIfDefined() ??
StringSource.Empty).ToRuntimeString();
if (actionId.IsEmpty())
{
actionId = ActionDefines.GetIdFromName(actionPart.LocalName);
}
var actionText =
(attribute.ArgumentsOptional[ActionAttribute.ActionAttribute_Text].GetStringValueIfDefined() ??
StringSource.Empty).ToRuntimeString();
if (actionText.IsEmpty())
{
actionText = actionId;
}
actionText = actionText.Replace("&", String.Empty);
var vsShortcuts =
attribute.ArgumentsOptional[ActionAttribute.ActionAttribute_VsShortcuts].GetArrayValueIfDefined();
var ideaShortcuts =
attribute.ArgumentsOptional[ActionAttribute.ActionAttribute_IdeaShortcuts].GetArrayValueIfDefined();
if (actionId.Equals("CompleteCodeBasic"))
{
vsShortcuts = new object[] { "Control+Space" }
}
;
if (actionId.Equals("CompleteStatement"))
{
vsShortcuts = new object[] { "Control+Shift+Enter" }
}
;
if (actionId.Equals("CompleteCodeBasic"))
{
ideaShortcuts = new object[] { "Control+Space" }
}
;
if (actionId.Equals("CompleteStatement"))
{
ideaShortcuts = new object[] { "Control+Shift+Enter" }
}
;
string pathToTheRoot;
try
{
pathToTheRoot =
(context.GetComponent <ActionPresentationHelper>()
.GetPathPresentationToRoot(actionManager.Defs.GetActionDefById(actionId)));
}
catch (Exception e)
{
pathToTheRoot = "";
}
if (!pathToTheRoot.IsEmpty() && !actionText.IsEmpty())
{
pathToTheRoot = pathToTheRoot.Replace('→', '|') + " | " + actionText;
}
var actionElement = new XElement("Action");
var pattern = new Regex("[_.]");
actionId = pattern.Replace(actionId, String.Empty);
actionElement.Add(
new XAttribute("id", actionId),
new XAttribute("title", actionText),
new XAttribute("menupath", pathToTheRoot));
var accessIntroChunk = XmlHelpers.CreateChunk(actionId);
var accessIntroWrapper = new XElement("p");
if (!pathToTheRoot.IsNullOrEmpty())
{
var menupPathChunk = XmlHelpers.CreateChunk(actionId);
pathToTheRoot =
pathToTheRoot.Replace("ReSharper | Navigate ", "%navigateMenu%")
.Replace("ReSharper | Windows ", "%windowsMenu%");
menupPathChunk.Add(new XElement("menupath", pathToTheRoot));
accessIntroWrapper.Add(new XElement("menupath", pathToTheRoot));
accessIntroWrapper.Add(new XElement("br"));
menuPathLibrary.Root.Add(menupPathChunk);
}
if (ideaShortcuts != null || vsShortcuts != null)
{
accessIntroWrapper.Add(new XElement("shortcut", new XAttribute("key", actionId)));
accessIntroWrapper.Add(new XElement("br"));
}
accessIntroWrapper.Add(new XElement("code", String.Format("ReSharper_{0}", actionId),
new XAttribute("product", "rs,dcv")));
accessIntroChunk.Add(accessIntroWrapper);
accessIntroLibrary.Root.Add(accessIntroChunk);
AddShortcuts(ideaShortcuts, actionElement, "rs");
AddShortcuts(vsShortcuts, actionElement, "vs");
if (actionId == "ParameterInfoShow")
{
actionElement.Add(new XElement("Shortcut", "Control+Shift+Space", new XAttribute("layout", "vs")));
}
if (actionId == "GotoDeclaration")
{
actionElement.Add(new XElement("Shortcut", "F12", new XAttribute("layout", "vs")));
}
if (actionId == "GotoImplementation")
{
actionElement.Add(new XElement("Shortcut", "Ctrl+F12", new XAttribute("layout", "vs")));
}
// TODO: check if this hack works
actionMapElement.Add(actionElement);
}
shortcutsXmlDoc.Save(Path.Combine(outputFolder, "keymap.xml"));
menuPathLibrary.Save(Path.Combine(outputFolder, menuPathLibId + ".xml"));
accessIntroLibrary.Save(Path.Combine(outputFolder, accessIntroLibId + ".xml"));
return("Shortcuts and actions");
}
protected override string GenerateContent(IDataContext context, string outputFolder)
{
const string macroTopicId = "Template_Macros";
var macroLibrary = XmlHelpers.CreateHmTopic(macroTopicId);
var macroChunk = XmlHelpers.CreateChunk("macro_table");
var macroTable = XmlHelpers.CreateTable(new[] { "Expression", "Description", "Details" }, null);
var macros = Shell.Instance.GetComponent <MacroManager>().Definitions;
foreach (var macroDefinition in macros)
{
var macroRow = new XElement("tr");
var longDescription = MacroDescriptionFormatter.GetMacroAttribute(macroDefinition).LongDescription;
var shortDescription = MacroDescriptionFormatter.GetMacroAttribute(macroDefinition).ShortDescription;
var macroId = MacroDescriptionFormatter.GetMacroAttribute(macroDefinition).Name;
const string paramMatch = @"{#0:(.*)}";
var parameters = macroDefinition.Parameters;
MatchCollection paramNames = null;
if (shortDescription != null)
{
paramNames = Regex.Matches(shortDescription, paramMatch);
shortDescription = Regex.Replace(shortDescription, paramMatch, @"<b>$+</b>");
}
var expressionCellRaw = "<td><code>" + macroId + "()" + "</code></td>";
var expressionCell = XElement.Parse(expressionCellRaw);
expressionCell.Add(new XAttribute("id", macroId));
var shortDescriptionCellRaw = "<td>" + shortDescription + "</td>";
var shortDescriptionCell = XElement.Parse(shortDescriptionCellRaw);
var paramNode = new XElement("list");
if (paramNames != null)
{
for (int idx = 0; idx < paramNames.Count; idx++)
{
var parameterInfo = parameters[idx];
paramNode.Add(new XElement("li",
new XElement("b",
paramNames[idx].Groups[1].Value),
GetParameterAsString(parameterInfo.ParameterType)));
}
}
var paramHeader = paramNode.HasElements ? new XElement("p", "Macro parameters:") : null;
macroRow.Add(expressionCell,
shortDescriptionCell,
new XElement("td",
longDescription,
paramHeader,
paramNode,
XmlHelpers.CreateInclude("TR", "macros_" + macroId)));
macroTable.Add(macroRow);
}
macroChunk.Add(macroTable);
macroLibrary.Root.Add(XmlHelpers.CreateInclude("Templates__Template_Basics__Template_Macros", "intro"));
macroLibrary.Root.Add(new XElement("p", "Here is the full list of template macros provided by ReSharper:"));
macroLibrary.Root.Add(macroChunk);
macroLibrary.Save(Path.Combine(outputFolder, macroTopicId + ".xml"));
return("Template macros");
}
protected override string GenerateContent(IDataContext context, string outputFolder)
{
const string caTopicId = "Fix_in_Scope_Chunks";
var inScopeLibrary = XmlHelpers.CreateHmTopic(caTopicId);
var qfChunk = XmlHelpers.CreateChunk("qf_list");
var caChunk = XmlHelpers.CreateChunk("ca_list");
var qfListByLang = new List <Tuple <string, XElement> >();
var caListByLang = new List <Tuple <string, XElement> >();
var qfLists = new Dictionary <string, XElement>();
var caLists = new Dictionary <string, XElement>();
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
Type[] types;
try { types = assembly.GetTypes(); }
catch (Exception e) {
continue;
}
foreach (var type in types)
{
if (typeof(IBulkAction).IsAssignableFrom(type) && !type.IsInterface && !type.IsAbstract)
{
var text = "";
try
{
text =
type.GetProperty("BulkText")
.GetValue(FormatterServices.GetUninitializedObject(type), null)
.ToString();
}
catch (Exception)
{
try
{
text =
type.GetProperty("Text")
.GetValue(FormatterServices.GetUninitializedObject(type), null)
.ToString();
}
catch (Exception)
{
// ignored
}
}
var actionElement = new XElement("li", text + Environment.NewLine,
new XComment(type.FullName),
XmlHelpers.CreateInclude("Fix_in_Scope_Static_Chunks", type.FullName.NormalizeStringForAttribute()));
var lang = GeneralHelpers.TryGetLang(type.FullName);
if (typeof(IContextAction).IsAssignableFrom(type))
{
caListByLang.Add(new Tuple <string, XElement>(lang, actionElement));
if (!caLists.ContainsKey(lang))
{
caLists.Add(lang, new XElement("list"));
}
}
if (typeof(IQuickFix).IsAssignableFrom(type))
{
qfListByLang.Add(new Tuple <string, XElement>(lang, actionElement));
if (!qfLists.ContainsKey(lang))
{
qfLists.Add(lang, new XElement("list"));
}
}
}
}
}
foreach (var list in qfLists)
{
foreach (var qfListItem in qfListByLang)
{
if (list.Key == qfListItem.Item1)
{
list.Value.Add(qfListItem.Item2);
}
}
var langChapter = XmlHelpers.CreateChapter(list.Key);
langChapter.Add(list.Value);
qfChunk.Add(langChapter);
}
foreach (var list in caLists)
{
foreach (var qfListItem in caListByLang)
{
if (list.Key == qfListItem.Item1)
{
list.Value.Add(qfListItem.Item2);
}
}
var langChapter = XmlHelpers.CreateChapter(list.Key);
langChapter.Add(list.Value);
caChunk.Add(langChapter);
}
inScopeLibrary.Root.Add(new XComment("Total quick-fix in scope: " + qfListByLang.Count()));
inScopeLibrary.Root.Add(new XComment("Total context actions in scope: " + caListByLang.Count()));
inScopeLibrary.Root.Add(qfChunk);
inScopeLibrary.Root.Add(caChunk);
inScopeLibrary.Save(Path.Combine(outputFolder, caTopicId + ".xml"));
return("Fix in scope actions");
}
private void CreateXml(TemplateApplicability applicability, IContextBoundSettingsStore bound,
string saveDirectoryPath, string version, IDataContext context)
{
string type;
ScopeFilter scopeFilter = ScopeFilter.Language;
switch (applicability)
{
case TemplateApplicability.Live:
type = "Live";
break;
case TemplateApplicability.Surround:
type = "Surround";
break;
case TemplateApplicability.File:
type = "File";
scopeFilter = ScopeFilter.Project;
break;
default: return;
}
var topicId = "Reference__Templates_Explorer__" + type + "_Templates";
var fileName = Path.Combine(saveDirectoryPath, topicId + ".xml");
var topic = XmlHelpers.CreateHmTopic(topicId);
var topicRoot = topic.Root;
topicRoot.Add(new XElement("p",
new XElement("menupath", "ReSharper | Templates Explorer | " + type + " Templates")));
topicRoot.Add(new XElement("p",
"This section lists all predefined " + type + " templates in ReSharper " + version + "."));
topicRoot.Add(new XElement("p", XmlHelpers.CreateInclude("Templates__Template_Basics__Template_Types", type)));
var summaryTable = XmlHelpers.CreateTable(new[] { "Template", "Description" }, new[] { "20%", "80%" });
var summaryItems = new List <Tuple <string, XElement> >();
var tables = new Dictionary <string, XElement>();
var defaultTemplates = context.GetComponent <StoredTemplatesProvider>()
.EnumerateTemplates(bound, applicability, false);
var myScopeCategoryManager = context.GetComponent <ScopeCategoryManager>();
foreach (var template in defaultTemplates)
{
var templateIdPresentable = !template.Shortcut.IsNullOrEmpty() ? template.Shortcut : template.Description;
templateIdPresentable = Regex.Replace(templateIdPresentable, "&Enum", "Enum");
var currentTemplateLangs = new List <string>();
var imported = String.Empty;
var scopeString = String.Empty;
var cat = String.Empty;
foreach (var category in template.Categories)
{
if (category.Contains("Imported"))
{
imported = category;
break;
}
if (category.Contains("C#"))
{
cat = "C#";
}
if (category.Contains("VB.NET"))
{
cat = "VB.NET";
}
}
foreach (var point in template.ScopePoints)
{
foreach (var provider in myScopeCategoryManager.GetCoveredProviders(scopeFilter, point))
{
var lang = provider.CategoryCaption;
if (lang == "ASP.NET" && type == "Surround" && !cat.IsNullOrEmpty())
{
lang = lang + "(" + cat + ")";
}
if (!lang.IsNullOrEmpty())
{
currentTemplateLangs.Add(lang);
if (!tables.ContainsKey(lang))
{
tables.Add(lang, XmlHelpers.CreateTable(new[] { "Template", "Details" }, new[] { "20%", "80%" }));
}
}
}
if (currentTemplateLangs.Count == 0)
{
MessageBox.ShowExclamation(String.Format("The '{0}' template has no associated languages",
templateIdPresentable));
}
scopeString += " " + point.PresentableShortName + ",";
}
scopeString = scopeString.TrimEnd(',');
var paramElement = new XElement("list");
foreach (var param in template.Fields)
{
var expr = param.Expression as MacroCallExpressionNew;
var paramItemElement = new XElement("li", new XElement("code", param.Name));
if (expr != null)
{
var macro = MacroDescriptionFormatter.GetMacroAttribute(expr.Definition);
paramItemElement.Add(" - " + macro.LongDescription + " (",
XmlHelpers.CreateHyperlink(macro.Name, "Template_Macros", macro.Name),
")");
}
else
{
paramItemElement.Add(" - " + "no macro");
}
paramElement.Add(paramItemElement);
}
if (template.Text.Contains("$SELECTION$"))
{
paramElement.Add(new XElement("li",
new XElement("code", "SELECTION"), " - The text selected by the user before invoking the template."));
}
if (template.Text.Contains("$END$"))
{
paramElement.Add(new XElement("li",
new XElement("code", "END"), " - The caret position after the template is applied."));
}
var processedLangs = new List <string>();
foreach (var lang in currentTemplateLangs)
{
if (!processedLangs.Contains(lang))
{
AddTemplateRow(tables, summaryItems, lang, templateIdPresentable, template, scopeString, paramElement, type,
imported);
processedLangs.Add(lang);
}
}
}
foreach (var table in tables)
{
summaryTable.Add(new XElement("tr",
new XElement("td",
new XAttribute("colspan", "2"),
new XElement("b", table.Key))));
foreach (var item in summaryItems)
{
if (item.Item1 == table.Key)
{
summaryTable.Add(item.Item2);
}
}
var langForHeading = table.Key;
if (langForHeading == "Global")
{
langForHeading = "Global Usage";
}
CreateTopicForLang(langForHeading, type, table.Value, saveDirectoryPath, version);
}
var indexChapter = XmlHelpers.CreateChapter(String.Format("Index of {0} Templates", type));
topicRoot.Add(new XComment("Total " + type + " templates: " + summaryItems.Count));
indexChapter.Add(summaryTable);
topicRoot.Add(indexChapter);
topic.Save(fileName);
}
