public DocumentationGenerator Download(DocumentType docType,
string fileName,
VideoForUser video)
{
DocumentationGenerator documentGenerator = DocumentationGenerator.Create(_domain, _fontPath, docType, fileName);
var fields = new List <string> {
"Отрывок текста"
};
if (video.HasAnyTranslation)
{
fields.Add("Перевод");
}
var tableData = new TableData(fields.Count, false);
tableData.AddHeader(fields);
foreach (var sentence in video.Sentences)
{
fields = new List <string> {
sentence.Item1
};
if (video.HasTranslation(sentence))
{
fields.Add(sentence.Item2);
}
tableData.AddRow(fields);
}
documentGenerator.AddHeader(string.Format("Текст из видео «{0}»", video.Title));
documentGenerator.AddTable(tableData);
return(documentGenerator);
}
public void HappyFlow()
{
var dg = new DocumentationGenerator();
var result = dg.GenerateDocumentation();
Assert.That(result, Is.Not.Null);
}
public void ShowColumnDocumentation(bool showInTaskbar)
{
var documentationGenerator = new DocumentationGenerator(ChooseColumnsTab.ViewInfo.ParentColumn);
DocumentationViewer documentationViewer = new DocumentationViewer(showInTaskbar);
documentationViewer.DocumentationHtml = documentationGenerator.GetDocumentationHtmlPage();
documentationViewer.Show(this);
}
public void should_load_xml_files_if_names_used()
{
var xmlLoader = MockRepository.GenerateMock<IXmlLoader>();
var generator = new DocumentationGenerator(StubAssemblyLoader, xmlLoader, StubParser, StubWriter, StubResourceManager, StubEventAggregator);
generator.SetXmlFiles(new[] { "assembly.xml", "assembly2.xml" });
xmlLoader.AssertWasCalled(x => x.LoadFrom("assembly.xml"));
xmlLoader.AssertWasCalled(x => x.LoadFrom("assembly2.xml"));
}
public void should_load_assemblies_if_strings_used()
{
var assemblyLoader = MockRepository.GenerateMock<IAssemblyLoader>();
var generator = new DocumentationGenerator(assemblyLoader, StubXmlLoader, StubParser, StubWriter, StubResourceManager, StubEventAggregator);
generator.SetAssemblies(new[] { "assembly.dll", "assembly2.dll" });
assemblyLoader.AssertWasCalled(x => x.LoadFrom("assembly.dll"));
assemblyLoader.AssertWasCalled(x => x.LoadFrom("assembly2.dll"));
}
public void should_load_assemblies_if_strings_used()
{
var assemblyLoader = MockRepository.GenerateMock <IAssemblyLoader>();
var generator = new DocumentationGenerator(assemblyLoader, StubXmlLoader, StubParser, StubWriter, StubResourceManager, StubEventAggregator);
generator.SetAssemblies(new[] { "assembly.dll", "assembly2.dll" });
assemblyLoader.AssertWasCalled(x => x.LoadFrom("assembly.dll"));
assemblyLoader.AssertWasCalled(x => x.LoadFrom("assembly2.dll"));
}
public void should_not_error_if_it_can_not_find_assemblies_to_doc()
{
var resourceManager = MockRepository.GenerateMock<IUntransformableResourceManager>();
var generator = new DocumentationGenerator(StubAssemblyLoader, StubXmlLoader, StubParser, StubWriter, resourceManager, StubEventAggregator);
generator.SetOutputPath("output-dir");
generator.Generate();
StubWriter.AssertWasNotCalled(x => x.CreatePagesFromDirectory(null, null, null), x => x.Constraints(Is.Anything(), Is.Anything(), Is.Anything()));
}
public void should_load_xml_files_if_names_used()
{
var xmlLoader = MockRepository.GenerateMock <IXmlLoader>();
var generator = new DocumentationGenerator(StubAssemblyLoader, xmlLoader, StubParser, StubWriter, StubResourceManager, StubEventAggregator);
generator.SetXmlFiles(new[] { "assembly.xml", "assembly2.xml" });
xmlLoader.AssertWasCalled(x => x.LoadFrom("assembly.xml"));
xmlLoader.AssertWasCalled(x => x.LoadFrom("assembly2.xml"));
}
public void should_not_error_if_it_can_not_find_assemblies_to_doc()
{
var resourceManager = MockRepository.GenerateMock <IUntransformableResourceManager>();
var generator = new DocumentationGenerator(StubAssemblyLoader, StubXmlLoader, StubParser, StubWriter, resourceManager, StubEventAggregator);
generator.SetOutputPath("output-dir");
generator.Generate();
StubWriter.AssertWasNotCalled(x => x.CreatePagesFromDirectory(null, null, null), x => x.Constraints(Is.Anything(), Is.Anything(), Is.Anything()));
}
public void should_pass_default_output_path_to_writer_if_not_set()
{
var writer = MockRepository.GenerateMock<IBulkPageWriter>();
var generator = new DocumentationGenerator(StubAssemblyLoader, StubXmlLoader, StubParser, writer, StubResourceManager, StubEventAggregator);
generator.SetAssemblies(new[] { "unimportant_file_path" });
generator.Generate();
writer.AssertWasCalled(x => x.CreatePagesFromDirectory(null, null, null),
x => x.Constraints(Is.Anything(), Is.Equal("output"), Is.Anything()));
}
public void generate_should_pass_assemblies_to_parser_when_set_directly()
{
var parser = MockRepository.GenerateMock <IAssemblyXmlParser>();
var generator = new DocumentationGenerator(StubAssemblyLoader, StubXmlLoader, parser, StubWriter, StubResourceManager, StubEventAggregator);
generator.SetAssemblies(new[] { typeof(IAssemblyLoader).Assembly });
generator.Generate();
parser.AssertWasCalled(x => x.CreateDocumentModel(null, null),
x => x.Constraints(List.ContainsAll(new[] { typeof(IAssemblyLoader).Assembly }), Is.Anything()));
}
public void generate_should_pass_assemblies_to_parser_when_set_directly()
{
var parser = MockRepository.GenerateMock<IAssemblyXmlParser>();
var generator = new DocumentationGenerator(StubAssemblyLoader, StubXmlLoader, parser, StubWriter, StubResourceManager, StubEventAggregator);
generator.SetXmlContent(new[] { "content" });
generator.Generate();
parser.AssertWasCalled(x => x.CreateDocumentModel(null, null),
x => x.Constraints(Is.Anything(), List.ContainsAll(new[] { "content" })));
}
public void should_pass_default_output_path_to_writer_if_not_set()
{
var writer = MockRepository.GenerateMock <IBulkPageWriter>();
var generator = new DocumentationGenerator(StubAssemblyLoader, StubXmlLoader, StubParser, writer, StubResourceManager, StubEventAggregator);
generator.SetAssemblies(new[] { "unimportant_file_path" });
generator.Generate();
writer.AssertWasCalled(x => x.CreatePagesFromDirectory(null, null, null),
x => x.Constraints(Is.Anything(), Is.Equal("output"), Is.Anything()));
}
public void should_move_untransformable_resources_to_output_dir()
{
var resourceManager = MockRepository.GenerateMock <IUntransformableResourceManager>();
var generator = new DocumentationGenerator(StubAssemblyLoader, StubXmlLoader, StubParser, StubWriter, resourceManager, StubEventAggregator);
generator.SetAssemblies(new[] { "unimportant_file_path" });
generator.SetOutputPath("output-dir");
generator.Generate();
resourceManager.AssertWasCalled(x => x.MoveResources(null, null),
x => x.Constraints(Is.Anything(), Is.Equal("output-dir")));
}
public DocumentationGenerator Download(DocumentType docType, string fileName, ComparisonForUser comparisonForUser)
{
string header = comparisonForUser.Title;
DocumentationGenerator documentGenerator = DocumentationGenerator.Create(_domain, _fontPath, docType, fileName);
documentGenerator.AddHeader(header, false);
if (comparisonForUser.HasDescription)
{
documentGenerator.AddParagraph(TextFormatter.AppendCharIfNeed(comparisonForUser.Description));
}
foreach (ComparisonItemForUser item in comparisonForUser.Items)
{
string title = item.Title;
if (item.HasTranslatedTitle)
{
title += " – " + item.TitleTranslated;
}
documentGenerator.AddSubheader(title);
documentGenerator.AddParagraph(item.GetRuleHeader());
int ruleNumber = 1;
foreach (ComparisonRuleForUser rule in item.Rules)
{
string ruleDescription = TextFormatter.AppendCharIfNeed(rule.Description);
if (!item.IsOneRule)
{
ruleDescription = ruleNumber + ". " + ruleDescription;
ruleNumber++;
}
documentGenerator.AddParagraph(ruleDescription);
if (EnumerableValidator.IsNotEmpty(rule.Examples))
{
foreach (ComparisonRuleExampleForUser example in @rule.Examples)
{
documentGenerator.AddParagraph(example.Example.Source.Text + " – "
+ example.Example.Translation.Text,
new TextFormat {
CountLeftPaddings = 1
});
if (!string.IsNullOrWhiteSpace(example.Description))
{
documentGenerator.AddParagraph("Пояснение к примеру: "
+ TextFormatter.AppendCharIfNeed(example.Description),
new TextFormat {
IsItalic = true, CountLeftPaddings = 1
});
}
}
}
}
}
return(documentGenerator);
}
public void set_assemblies_should_fire_event_if_bad_file_found()
{
var parser = MockRepository.GenerateMock<IAssemblyXmlParser>();
var badFileFound = false;
var generator = new DocumentationGenerator(new AssemblyLoader(), StubXmlLoader, parser, StubWriter, StubResourceManager);
generator.BadFileEvent += (s, e) => badFileFound = true;
generator.SetAssemblies(new[] { "docu.pdb" });
badFileFound.ShouldBeTrue();
}
public void should_move_untransformable_resources_to_output_dir()
{
var resourceManager = MockRepository.GenerateMock<IUntransformableResourceManager>();
var generator = new DocumentationGenerator(StubAssemblyLoader, StubXmlLoader, StubParser, StubWriter, resourceManager, StubEventAggregator);
generator.SetAssemblies(new[] { "unimportant_file_path" });
generator.SetOutputPath("output-dir");
generator.Generate();
resourceManager.AssertWasCalled(x => x.MoveResources(null, null),
x => x.Constraints(Is.Anything(), Is.Equal("output-dir")));
}
internal TemplateDocumentGenerator(ProjectDocumentationModel project,
DocumentationGenerator documentationGenerator,
TemplateModel template, DocumentFileModel document,
string urlBase, DocumentFileModelCollection allDocuments)
{
Project = project;
Generator = documentationGenerator;
Template = template;
Document = document;
UrlBase = urlBase;
DocumentsGenerated = allDocuments;
}
public void TestSetUp()
{
this.schemas = new List <Schema>();
this.dataServices = new DataServices {
Schemas = this.schemas
};
this.entityFramework = new EntityFramework {
DataServices = this.dataServices
};
this.documentationGenerator = new DocumentationGenerator();
this.schema = this.GetSchema("microsoft.graph");
}
internal TemplateDocumentGenerator(Models.Projects.ProjectDocumentationModel objProject,
DocumentationGenerator objDocumentationGenerator,
TemplateModel objTemplate, DocumentFileModel objDocument,
string strUrlBase,
DocumentFileModelCollection objColAllDocuments)
{
Project = objProject;
Generator = objDocumentationGenerator;
Template = objTemplate;
Document = objDocument;
UrlBase = strUrlBase;
DocumentsGenerated = objColAllDocuments;
}
public void set_assemblies_should_publish_event_if_bad_file_found()
{
var ev = MockRepository.GenerateMock<BadFileEvent>();
var parser = MockRepository.GenerateMock<IAssemblyXmlParser>();
StubEventAggregator.Stub(x => x.GetEvent<BadFileEvent>())
.Return(ev);
var generator = new DocumentationGenerator(new AssemblyLoader(), StubXmlLoader, parser, StubWriter, StubResourceManager, StubEventAggregator);
generator.SetAssemblies(new[] { "docu.pdb" });
ev.AssertWasCalled(x => x.Publish("docu.pdb"));
}
public void set_assemblies_should_publish_event_if_bad_file_found()
{
var ev = MockRepository.GenerateMock <BadFileEvent>();
var parser = MockRepository.GenerateMock <IAssemblyXmlParser>();
StubEventAggregator.Stub(x => x.GetEvent <BadFileEvent>())
.Return(ev);
var generator = new DocumentationGenerator(new AssemblyLoader(), StubXmlLoader, parser, StubWriter, StubResourceManager, StubEventAggregator);
generator.SetAssemblies(new[] { "docu.pdb" });
ev.AssertWasCalled(x => x.Publish("docu.pdb"));
}
public void generate_should_pass_xmls_to_parser_when_set_by_name()
{
var parser = MockRepository.GenerateMock <IAssemblyXmlParser>();
var generator = new DocumentationGenerator(StubAssemblyLoader, StubXmlLoader, parser, StubWriter, StubResourceManager, StubEventAggregator);
StubXmlLoader.Stub(x => x.LoadFrom(null))
.IgnoreArguments()
.Return("content");
generator.SetXmlFiles(new[] { "assembly.xml" });
generator.Generate();
parser.AssertWasCalled(x => x.CreateDocumentModel(null, null),
x => x.Constraints(Is.Anything(), List.ContainsAll(new[] { "content" })));
}
public void GenerateDocumentationForTagLib()
{
var lib = new TagLib();
lib.Register(new TestGroup());
//When
var model = new DocumentationGenerator().For(lib).BuildModel();
var result = JsonConvert.SerializeObject(model, Formatting.Indented);
// Then
File.WriteAllText("c:/Temp/TagLib.json", result);
Assert.That(result, Is.Not.Null);
}
public void generate_should_pass_assemblies_to_parser_when_set_by_name()
{
var parser = MockRepository.GenerateMock<IAssemblyXmlParser>();
var generator = new DocumentationGenerator(StubAssemblyLoader, StubXmlLoader, parser, StubWriter, StubResourceManager);
StubAssemblyLoader.Stub(x => x.LoadFrom(null))
.IgnoreArguments()
.Return(typeof(IAssemblyLoader).Assembly);
generator.SetAssemblies(new[] { "assembly.dll" });
generator.Generate();
parser.AssertWasCalled(x => x.CreateDocumentModel(null, null),
x => x.Constraints(List.ContainsAll(new[] { typeof(IAssemblyLoader).Assembly }), Is.Anything()));
}
public void generate_should_pass_xmls_to_parser_when_set_by_name()
{
var parser = MockRepository.GenerateMock<IAssemblyXmlParser>();
var generator = new DocumentationGenerator(StubAssemblyLoader, StubXmlLoader, parser, StubWriter, StubResourceManager, StubEventAggregator);
StubXmlLoader.Stub(x => x.LoadFrom(null))
.IgnoreArguments()
.Return("content");
generator.SetXmlFiles(new[] { "assembly.xml" });
generator.Generate();
parser.AssertWasCalled(x => x.CreateDocumentModel(null, null),
x => x.Constraints(Is.Anything(), List.ContainsAll(new[] { "content" })));
}
public void should_pass_document_model_to_writer()
{
var writer = MockRepository.GenerateMock <IBulkPageWriter>();
var generator = new DocumentationGenerator(StubAssemblyLoader, StubXmlLoader, StubParser, writer, StubResourceManager, StubEventAggregator);
var documentModel = new List <Namespace>();
StubParser.Stub(x => x.CreateDocumentModel(null, null))
.IgnoreArguments()
.Return(documentModel);
generator.SetAssemblies(new [] { "unimportant_file_path" });
generator.Generate();
writer.AssertWasCalled(x => x.CreatePagesFromDirectory(null, null, null),
x => x.Constraints(Is.Anything(), Is.Anything(), Is.Equal(documentModel)));
}
public void should_pass_document_model_to_writer()
{
var writer = MockRepository.GenerateMock<IBulkPageWriter>();
var generator = new DocumentationGenerator(StubAssemblyLoader, StubXmlLoader, StubParser, writer, StubResourceManager, StubEventAggregator);
var documentModel = new List<Namespace>();
StubParser.Stub(x => x.CreateDocumentModel(null, null))
.IgnoreArguments()
.Return(documentModel);
generator.SetAssemblies(new []{"unimportant_file_path"});
generator.Generate();
writer.AssertWasCalled(x => x.CreatePagesFromDirectory(null, null, null),
x => x.Constraints(Is.Anything(), Is.Anything(), Is.Equal(documentModel)));
}
public byte[] Generate(long languageId, UserLanguages userLanguages)
{
var allMaterialsQuery = new AllMaterialsQuery(languageId, userLanguages, _forbiddenSectionsChecker);
Dictionary <SectionId, List <Tuple <long, string, DateTime> > > tupleBySections =
allMaterialsQuery.GetDataBySections();
string keyFromContent = GetKeyFromContent(tupleBySections);
string zipKey = "AllMaterials" + "_" + keyFromContent + "_" + userLanguages.From.ShortName + "_"
+ userLanguages.To.ShortName + ".zip";
byte[] result = _cache.Get(zipKey);
if (result != null)
{
return(result);
}
foreach (var pairBySection in tupleBySections)
{
SectionId sectionId = pairBySection.Key;
string folderName = allMaterialsQuery.GetHeader(sectionId);
foreach (var tuple in pairBySection.Value)
{
DocumentationGenerator generator = GetGenerator(allMaterialsQuery, sectionId, tuple.Item1,
tuple.Item2);
if (generator == null)
{
//TODO: логировать и отсылать мне на почту
continue;
}
Stream fileContent = generator.Generate();
if (fileContent == null)
{
//TODO: логировать и отсылать мне на почту
continue;
}
string entryName = folderName + "/" + generator.FileName;
_zipCompressor.AddFileToArchive(entryName, fileContent);
}
}
result = _zipCompressor.GetArchive();
WriteToCache(zipKey, result);
return(result);
}
public DocumentationGenerator Download(DocumentType docType,
string fileName,
Dictionary <KnowledgeDataType, List <GeneratedKnowledgeItem> >
generatedItems)
{
DocumentationGenerator documentGenerator = DocumentationGenerator.Create(_domain, _fontPath, docType,
fileName);
var tables = new Dictionary <string, TableData>();
foreach (KnowledgeDataType knowledgeDataType in generatedItems.Keys)
{
var tableData = new TableData(2, true);
string tableHeader = GetTableHeader(knowledgeDataType);
if (!string.IsNullOrEmpty(tableHeader))
{
tableData.AddHeader(tableHeader, "Перевод");
string subHeader = GetHeader(knowledgeDataType);
tables.Add(subHeader, tableData);
}
List <GeneratedKnowledgeItem> items = generatedItems[knowledgeDataType];
foreach (GeneratedKnowledgeItem item in items)
{
var sourceTranslation = (SourceWithTranslation)item.ParsedData;
tableData.AddRow(sourceTranslation.Source.Text, sourceTranslation.Translation.Text);
}
}
if (string.IsNullOrEmpty(Header))
{
Header = "Генератор знаний";
}
documentGenerator.AddHeader(Header, false);
foreach (var pair in tables)
{
documentGenerator.AddHeader(pair.Key);
documentGenerator.AddTable(pair.Value);
}
return(documentGenerator);
}
public DocumentationGenerator Download(DocumentType docType,
string fileName,
RepresentationForUser representationForUser)
{
DocumentationGenerator documentGenerator = DocumentationGenerator.Create(_domain, _fontPath, docType, fileName);
var tableData = new TableData(2, true);
tableData.AddHeader("Слово", "Перевод");
foreach (RepresentationAreaForUser area in representationForUser.Areas)
{
tableData.AddRow(area.Source.Text, area.Translation.Text);
}
documentGenerator.AddHeader(string.Format("Визуальный словарь на тему «{0}»", representationForUser.Title));
documentGenerator.AddTable(tableData);
return(documentGenerator);
}
/// <summary>
/// Gemera la documentación
/// </summary>
private void GenerateDocuments()
{
if (ValidateData())
{
DocumentFileModelCollection objColDocuments;
ProgramModel objProgram = new ProgramParser().ParseSolution(fnSolution.FileName);
// Borra el directorio destino
Bau.Libraries.LibHelper.Files.HelperFiles.KillPath(pthTarget.PathName);
// Genera la documentación
objColDocuments = new DocumentationGenerator(GetParametersDocuments(), pthTarget.PathName).Process(objProgram);
// Muestra la documentación
txtLog.Text = objColDocuments.Debug(0);
// Muestra los nodos
trvNodes.Nodes.Clear();
ShowDocumentNodes(objColDocuments, null);
trvNodes.ExpandAll();
}
}
public DocumentationGenerator Download(DocumentType docType,
string fileName,
List <SourceWithTranslation> elemsWithTranslations)
{
DocumentationGenerator documentGenerator = DocumentationGenerator.Create(_domain, _fontPath, docType,
fileName);
var tableData = new TableData(2, true);
tableData.AddHeader(TableHeader, "Перевод");
foreach (SourceWithTranslation elem in elemsWithTranslations)
{
tableData.AddRow(elem.Source.Text, elem.Translation.Text);
}
documentGenerator.AddHeader(Header);
documentGenerator.AddTable(tableData);
return(documentGenerator);
}
public static void Main(string[] args)
{
Console.WriteLine("Sharptiles documentation generation");
if (args.Length != 1 && args.Length != 2)
{
throw new ArgumentException("Usage " + ASSEMLBY_NAME +
" <documentation target path> [--json]");
}
var json = false;
var targetPath = args[0];
if (args.Length == 2 && args[1].Equals("--json"))
{
json = true;
}
Console.WriteLine($"Generating to {targetPath}");
var generator = new DocumentationGenerator()
.For(Scope)
.AddSpecial(HandleHtmlTags);
// generator.CopyFiles(targetPath, templatePath);
try
{
if (json)
{
var documentation = generator.BuildModel();
var result = JsonConvert.SerializeObject(documentation, Formatting.Indented, new TypeJsonConverter(), new StringEnumConverter());
File.WriteAllText(targetPath, result);
}
else
{
var documentation = generator.GenerateDocumentation();
File.WriteAllText(targetPath, documentation);
}
}
catch (ExceptionWithContext EWC)
{
Console.WriteLine(EWC.Message);
Console.WriteLine(EWC.Context);
}
Console.WriteLine("Finished");
}
public ActionResult Download(UserLanguages userLanguages, string group, DocumentType type)
{
if (UserLanguages.IsInvalid(userLanguages))
{
return(RedirectToAction("Index", RouteConfig.VISUAL_DICTIONARIES_CONTROLLER_NAME));
}
RepresentationForUser representationForUser = GetRepresentationForUser(userLanguages, group);
if (representationForUser == null)
{
return(RedirectToActionPermanent("Index", RouteConfig.VISUAL_DICTIONARIES_CONTROLLER_NAME));
}
var downloader = new VisualDictionaryDownloader(WebSettingsConfig.Instance.DomainWithProtocol,
CommonConstants.GetFontPath(Server));
string fileName = string.Format("Визуальный словарь на тему {0}",
representationForUser.Title.ToLowerInvariant());
DocumentationGenerator documentGenerator = downloader.Download(type, fileName, representationForUser);
return(File(documentGenerator.Generate(), documentGenerator.ContentType, documentGenerator.FileName));
}
public ActionResult Download(UserLanguages userLanguages, DocumentType type)
{
if (IsInvalid(userLanguages))
{
return(RedirectToAction("Index", RouteConfig.MAIN_CONTROLLER_NAME));
}
List <SourceWithTranslation> words = GetWords(userLanguages);
string header = WebSettingsConfig.Instance.GetTemplateText(SectionId.PopularWord, PageId.Index,
TemplateId.Header);
var downloader = new PopularWordsDownloader(WebSettingsConfig.Instance.DomainWithProtocol,
CommonConstants.GetFontPath(Server))
{
Header = header
};
DocumentationGenerator documentGenerator = downloader.Download(type, header, words);
return(File(documentGenerator.Generate(), documentGenerator.ContentType, documentGenerator.FileName));
}
public DocumentationGenerator Download(DocumentType docType,
string fileName,
List <SourceWithTranslation> words)
{
DocumentationGenerator documentGenerator = DocumentationGenerator.Create(_domain, _fontPath, docType, fileName);
var tableData = new TableData(2, true);
tableData.AddHeader("Слово", "Перевод");
foreach (SourceWithTranslation word in words)
{
tableData.AddRow(word.Source.Text, word.Translation.Text);
}
if (string.IsNullOrEmpty(Header))
{
Header = "Минилекс Гуннемарка";
}
documentGenerator.AddHeader(Header);
documentGenerator.AddTable(tableData);
return(documentGenerator);
}
void IPropellerModule.Init(LoggerBase log, JsonValue settings, ISettingsSaver saver)
{
_log = log;
_saver = saver;
_settings = ClassifyJson.Deserialize <Settings>(settings) ?? new Settings();
var validPaths = new List <string>();
foreach (var path in _settings.Paths)
{
if (!Directory.Exists(path))
{
_log.Warn(@"DocGen: Warning: The folder ""{0}"" specified in the settings does not exist. Ignoring path.".Fmt(path));
}
else
{
validPaths.Add(path);
}
}
_settings.Paths = validPaths.ToArray();
saver.SaveSettings(ClassifyJson.Serialize(_settings));
string copyToPath = null;
if (_settings.DllTempPath != null)
{
// Try to clean up old folders we've created before
var tempPath = _settings.DllTempPath;
Directory.CreateDirectory(tempPath);
foreach (var path in Directory.GetDirectories(tempPath, "docgen-tmp-*"))
{
try { Directory.Delete(path, true); }
catch { }
}
// Find a new folder to put the DLL files into
int j = 1;
copyToPath = Path.Combine(tempPath, "docgen-tmp-" + j);
while (Directory.Exists(copyToPath))
{
j++;
copyToPath = Path.Combine(tempPath, "docgen-tmp-" + j);
}
Directory.CreateDirectory(copyToPath);
}
_docGen = new DocumentationGenerator(_settings.Paths, _settings.RequireAuthentication ? _settings.UsernamePasswordFile ?? "" : null, copyToPath);
lock (_log)
{
_log.Info("DocGen initialised with {0} assemblies: {1}".Fmt(_docGen.AssembliesLoaded.Count, _docGen.AssembliesLoaded.JoinString(", ")));
if (_docGen.AssemblyLoadErrors.Count > 0)
{
_log.Warn("{0} assembly load errors:".Fmt(_docGen.AssemblyLoadErrors.Count));
foreach (var tuple in _docGen.AssemblyLoadErrors)
{
_log.Warn("{0} error: {1}".Fmt(tuple.Item1, tuple.Item2));
}
}
}
}
internal ProgramDocumentationGenerator(DocumentationGenerator objGenerator)
{
DocumentationProcessor = objGenerator;
}
public void HappyFlow()
{
var dg = new DocumentationGenerator();
var result=dg.GenerateDocumentation();
Assert.That(result, Is.Not.Null);
}
private IEnumerable <ColumnDescriptor> GetChildColumns(ColumnDescriptor columnDescriptor)
{
return(DocumentationGenerator.GetChildColumns(columnDescriptor));
}
public static void Main(string[] args)
{
#if DEBUG
args = new[]
{
"D:/coding/MMM/src/StEn.MMM/Mql.Mail|D:/coding/MMM/src/StEn.MMM/Mql.Telegram",
"D:/coding/MMM/doc",
};
#endif
if (args.Length < 2)
{
Console.WriteLine("Not enough arguments given.");
Environment.Exit(1);
}
var pathToSourcesList = args[0].Split("|");
var pathToOutput = args[1];
foreach (var pathToSources in pathToSourcesList)
{
if (!Directory.Exists(pathToSources))
{
Console.WriteLine("Directory to sources does not exist.");
Environment.Exit(1);
}
if (!Directory.Exists(args[1]))
{
Console.WriteLine("Directory for output does not exist.");
Environment.Exit(1);
}
// Detect export file
var dllExportFile = Directory.EnumerateFiles(pathToSources, "*.*", SearchOption.AllDirectories)
.FirstOrDefault(file => file.ToLower().EndsWith("Module.cs".ToLower()));
// Detect project file
var projectFile = Directory.EnumerateFiles(pathToSources, "*.*", SearchOption.AllDirectories)
.FirstOrDefault(file => file.ToLower().EndsWith(".csproj".ToLower()));
var xmlCommentFile = Directory.EnumerateFiles(pathToSources, "*.*", SearchOption.AllDirectories)
.FirstOrDefault(file => file.ToLower().EndsWith($"{AssemblyPropertyParser.GetAssemblyNameByProjectFile(projectFile)}.xml".ToLower()) &&
file.ToLower().Contains("release"));
var binaryFile = Directory.EnumerateFiles(pathToSources, "*.*", SearchOption.AllDirectories)
.FirstOrDefault(file => file.ToLower().EndsWith($"{AssemblyPropertyParser.GetAssemblyNameByProjectFile(projectFile)}.dll".ToLower()) &&
file.ToLower().Contains("release"));
if (dllExportFile == null)
{
throw new FileNotFoundException($"{nameof(dllExportFile)} in {pathToSources} was not found");
}
if (projectFile == null)
{
throw new FileNotFoundException($"{nameof(projectFile)} in {pathToSources} was not found");
}
if (xmlCommentFile == null)
{
throw new FileNotFoundException($"{nameof(xmlCommentFile)} in {pathToSources} was not found");
}
if (binaryFile == null)
{
throw new FileNotFoundException($"{nameof(binaryFile)} in {pathToSources} was not found");
}
// Read exported functions and their properties
var functionDefinitions = DllExportParser.GetFunctionDefinitionBySourceFile(dllExportFile);
// Generate the template text
var templateText = MqlTemplateGenerator.GenerateTemplateText(
"Templates/Mql5Basic.template",
AssemblyPropertyParser.GetAssemblyNameByProjectFile(projectFile),
AssemblyPropertyParser.GetAssemblyVersionByProjectFile(projectFile),
functionDefinitions);
// Write the MQL template text to output files
MqlTemplateGenerator.WriteTemplateOutput(
$"{pathToOutput}/module_usage/implementation/metatrader5/MQL5/Experts/MMM_Modules/{AssemblyPropertyParser.GetAssemblyNameByProjectFile(projectFile).ToLower()}/{AssemblyPropertyParser.GetAssemblyNameByProjectFile(projectFile)}_{AssemblyPropertyParser.GetAssemblyVersionByProjectFile(projectFile)}.mq5",
templateText);
MqlTemplateGenerator.WriteTemplateOutput(
$"{pathToOutput}/module_usage/implementation/metatrader5/MQL5/Experts/MMM_Modules/{AssemblyPropertyParser.GetAssemblyNameByProjectFile(projectFile).ToLower()}/{AssemblyPropertyParser.GetAssemblyNameByProjectFile(projectFile)}_latest.mq5",
templateText);
// Write the online documentation to output files
var documentationText = DocumentationGenerator.GenerateDocumentationText(
xmlCommentFile,
binaryFile,
AssemblyPropertyParser.GetAssemblyNameByProjectFile(projectFile),
AssemblyPropertyParser.GetAssemblyVersionByProjectFile(projectFile),
functionDefinitions);
DocumentationGenerator.WriteTemplateOutput(
$"{pathToOutput}/module_usage/api/{AssemblyPropertyParser.GetAssemblyNameByProjectFile(projectFile).ToLower()}/{AssemblyPropertyParser.GetAssemblyNameByProjectFile(projectFile)}_{AssemblyPropertyParser.GetAssemblyVersionByProjectFile(projectFile)}.md",
documentationText);
DocumentationGenerator.WriteTemplateOutput(
$"{pathToOutput}/module_usage/api/{AssemblyPropertyParser.GetAssemblyNameByProjectFile(projectFile).ToLower()}/{AssemblyPropertyParser.GetAssemblyNameByProjectFile(projectFile)}_latest.md",
documentationText);
}
}
