Exemplo n.º 1
0
        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");
        }
Exemplo n.º 2
0
        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);
        }