Ejemplo n.º 1
0
        private void WeaveFromCSharpDocument(SplitPath codeFile,
                                             Document document)
        {
            SplitPath outputFile = CreateOutputPath(codeFile, _options.MarkdownExt);

            OutputBlocks(BlockListFromDocument(document), !outputFile);
        }
Ejemplo n.º 2
0
 private void AddToToc(SplitPath path)
 {
     if (_options.UpdateToc)
     {
         _tocManager.AddToToc(path);
     }
 }
Ejemplo n.º 3
0
 /*
 ## Initializing Page Specific Parameters
 ##
 ## There are a few built-in parameters that the theme can use. They are
 ## updated before processing each document by the method below. Refer to
 ## the documentation of the [PageParams](../LiterateCS.Theme/PageParams.html)
 ## class for more information about the parameters.
 */
 private void InitParams(SplitPath inputFile, SplitPath outputFile)
 {
     _params.Filename       = outputFile.FileNameWithoutExtension;
     _params.Root           = outputFile.RelativePathToRoot;
     _params.CurrentSection = _params.Toc.Flattened.FirstOrDefault(e =>
                                                                   e.File == inputFile.FilePath);
 }
Ejemplo n.º 4
0
        /*
         * Now we can enumerate the input files.
         */
        protected IEnumerable <SplitPath> InputFiles()
        {
            var filtRegexes = FilterRegexes();

            return(from file in DirHelpers.Dir(_options.InputPath.BasePath, "*", true)
                   let relPath = SplitPath.Split(_options.InputPath.BasePath, file)
                                 where filtRegexes.Any(re => re.IsMatch(relPath.FilePath))
                                 select relPath);
        }
Ejemplo n.º 5
0
        /*
         ### Output Path for a File
         ###For each input file we need to construct the output path. We take the base
         ###path from command line options and join it with the relative file path of
         ###the input file changing the extension simultaneously. We also check that the
         ###output directory exists, and create it when needed.
         */
        protected SplitPath CreateOutputPath(SplitPath codeFile, string extension)
        {
            var outputFile = _options.OutputPath + codeFile.ChangeExtension(extension);

            ConsoleOut("Generating {0} from file '{1}' into file '{2}'",
                       extension, codeFile.FilePath, outputFile.FilePath);
            DirHelpers.EnsureExists(outputFile.DirectoryName);
            return(outputFile);
        }
Ejemplo n.º 6
0
        /*
         * The mirror operation of defining an ID is making a token clickable by
         * surrounding it with an `<a>` tag. The target of the link is in the `href`
         * attribute, which is determined by the function below. The link consists
         * of the relative file path and the ID inside the file. The file path is
         * always used, even if the link target is inside the same file.
         */
        private string GetHrefForSymbol(ISymbol symbol)
        {
            var sref    = symbol.DeclaringSyntaxReferences.First();
            var reffile = SplitPath.Split(_options.InputPath.BasePath,
                                          sref.SyntaxTree.FilePath);
            var inputfile = SplitPath.Split(_options.InputPath.BasePath,
                                            _document.FilePath);

            return(Path.Combine(inputfile.RelativePathToRoot,
                                reffile.ChangeExtension("html").FilePath).Replace('\\', '/') +
                   "#" + GetSymbolId(symbol));
        }
Ejemplo n.º 7
0
        /*
         ### Enumerating Files in Solution
         ###When a solution file is used as an input, C# files are retrieved in a different way.
         ###They are enumerated using the Roslyn
         ###[workspace](https://github.com/dotnet/roslyn/wiki/Roslyn-Overview#working-with-a-workspace).
         */
        protected IEnumerable <Tuple <SplitPath, Document> > CSharpDocumentsInSolution()
        {
            var solution    = BuildSolution();
            var filtRegexes = FilterRegexes();

            return(from proj in CompileProjectsInSolution(solution)
                   from doc in proj.Documents
                   let relPath = SplitPath.Split(_options.InputPath.BasePath, doc.FilePath)
                                 where filtRegexes.Any(re => re.IsMatch(relPath.FilePath)) &&
                                 !(relPath.FilePath.EndsWith("AssemblyAttributes.cs") ||
                                   relPath.FilePath.EndsWith("AssemblyInfo.cs"))
                                 select Tuple.Create(relPath, doc));
        }
Ejemplo n.º 8
0
        /*
        ## Generating HTML Page from Code File
        ##
        ## Once a source file has been split into blocks, we can give the block
        ## list and the input and output file paths to the `Execute` method. This
        ## is where the HTML page is actually generated.
        */
        public void Execute(BlockList blocks, SplitPath inputFile,
                            SplitPath outputFile)
        {
            /*
             * First, we initialize the document-level parameters.
             */
            InitParams(inputFile, outputFile);

            /*
             * If the first block in the list is a markdown block, then we need to
             * check if it contains a front matter. We initialize the used template
             * to null, which selects the default template. The setting can be then
             * overridden in the front matter.
             */
            string template     = null;
            var    firstMdBlock = blocks.FirstOrDefault(b => b.Kind == BlockKind.Markdown);

            if (firstMdBlock != null)
            {
                template = ParseFrontMatter(
                    GetFrontMatter(firstMdBlock.Contents), !inputFile);
            }

            /*
             * Next, we iterate through the blocks, convert them to HTML, and finally
             * assign the resulted string into the `Contents` parameter, so that the
             * theme can access it.
             */
            using (var writer = new StringWriter())
            {
                foreach (var block in blocks)
                {
                    writer.Write(Markdown.ToHtml(block.Contents, _pipeline));
                }
                _params.Contents = writer.ToString();
            }

            /*
             * As the last step, we render the page using the theme, and write the
             * resulting HTML page to the output file.
             */
            using (var writer = File.CreateText(!outputFile))
                writer.Write(_theme.RenderPage(template, _params));
        }
Ejemplo n.º 9
0
        /*
        ## Adding New Sections
        ##
        ## Instead of adding a new entry to TOC while the documentation is being
        ## generated, we add it to a temporary list. This list is concatenated
        ## to the TOC before it is saved. If there is no file associated to the
        ## TOC (in which case the temporary list is null), then we don't need to
        ## do anything.
        */
        public void AddToToc(SplitPath path)
        {
            if (_addedSections == null)
            {
                return;
            }
            var section = FindSectionForFile(path.FilePath, Toc.Contents) ??
                          _addedSections.FirstOrDefault(s => s.File == path.FilePath);

            if (section == null)
            {
                _addedSections.Add(new Section()
                {
                    Page = path.FileNameWithoutExtension,
                    File = path.FilePath,
                    Desc = "TODO! Add page description."
                });
            }
        }
Ejemplo n.º 10
0
 /*
  * The rest of the methods are helper functions that process a single file
  * at a time; first they split it to blocks, and then call HTMLGenerator
  * to convert it to a HTML page.
  */
 private void WeaveFromCodeFile(SplitPath codeFile)
 {
     _generateHtml.Execute(BlockListFromCode(!codeFile), codeFile,
                           CreateOutputPath(codeFile, ".html"));
 }
Ejemplo n.º 11
0
 private void WeaveFromMarkdown(SplitPath mdFile)
 {
     _generateHtml.Execute(BlockListFromMarkdown(!mdFile), mdFile,
                           CreateOutputPath(mdFile, ".html"));
 }
Ejemplo n.º 12
0
 private void WeaveFromCSharpDocument(SplitPath codeFile, Document document)
 {
     _generateHtml.Execute(BlockListFromDocument(document), codeFile,
                           CreateOutputPath(codeFile, ".html"));
 }
Ejemplo n.º 13
0
        private void WeaveFromCode(SplitPath codeFile)
        {
            SplitPath outputFile = CreateOutputPath(codeFile, _options.MarkdownExt);

            OutputBlocks(BlockListFromCode(!codeFile), !outputFile);
        }
Ejemplo n.º 14
0
        /*
         ### Weaving the Output
         ###The rest of the code in this class consist of helper functions which
         ###split the input files to blocks and compile the output from them.
         ###Since the blocks already contain valid markdown, no further processing
         ###is needed to transform them.
         */
        private void WeaveFromMarkdown(SplitPath mdFile)
        {
            SplitPath outputFile = CreateOutputPath(mdFile, _options.MarkdownExt);

            OutputBlocks(BlockListFromMarkdown(!mdFile), !outputFile);
        }
Ejemplo n.º 15
0
 protected bool IsMarkdownFile(SplitPath file) =>
 file.Extension == _options.MarkdownExt;
Ejemplo n.º 16
0
 /*
  * Finally we need some helper functions to determine the type of a file. The
  * type of a file is deduced from its extension or from its name.
  */
 protected bool IsSourceFile(SplitPath file) =>
 file.Extension == _options.SourceExt;