Browse Source

build based on e0d090e

gh-pages
autodocs 8 years ago
parent
commit
ae8ca4068f
  1. 63
      latest/assets/arrow.svg
  2. 577
      latest/assets/documenter.css
  3. 129
      latest/assets/documenter.js
  4. 243
      latest/assets/search.js
  5. 8
      latest/customprocessing.html
  6. 2
      latest/documenter.html
  7. 47
      latest/fileformat.html
  8. 3
      latest/generated/example.html
  9. 116
      latest/generated/example.ipynb
  10. 11
      latest/generated/example.jl
  11. 2
      latest/index.html
  12. 20
      latest/outputformats.html
  13. 29
      latest/pipeline.html
  14. 2
      latest/search.html
  15. 259
      latest/search_index.js
  16. 1
      latest/siteinfo.js
  17. 3
      versions.js

63
latest/assets/arrow.svg

@ -0,0 +1,63 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->
<svg
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:cc="http://creativecommons.org/ns#"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:svg="http://www.w3.org/2000/svg"
xmlns="http://www.w3.org/2000/svg"
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
width="16.5mm"
height="8.6603003mm"
viewBox="0 0 58.464567 30.686103"
id="svg2"
version="1.1"
inkscape:version="0.91 r13725"
sodipodi:docname="arrow.svg">
<defs
id="defs4" />
<sodipodi:namedview
id="base"
pagecolor="#ffffff"
bordercolor="#666666"
borderopacity="1.0"
inkscape:pageopacity="0.0"
inkscape:pageshadow="2"
inkscape:zoom="11.2"
inkscape:cx="14.209234"
inkscape:cy="29.780479"
inkscape:document-units="px"
inkscape:current-layer="layer1"
showgrid="false"
inkscape:window-width="1920"
inkscape:window-height="1053"
inkscape:window-x="0"
inkscape:window-y="27"
inkscape:window-maximized="1" />
<metadata
id="metadata7">
<rdf:RDF>
<cc:Work
rdf:about="">
<dc:format>image/svg+xml</dc:format>
<dc:type
rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
<dc:title></dc:title>
</cc:Work>
</rdf:RDF>
</metadata>
<g
inkscape:label="Layer 1"
inkscape:groupmode="layer"
id="layer1"
transform="translate(0,-1021.6761)">
<path
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
d="m 0,1021.6761 35.433071,0 -17.716536,30.6861 z"
id="path4140"
inkscape:connector-curvature="0"
sodipodi:nodetypes="cccc" />
</g>
</svg>

After

Width:  |  Height:  |  Size: 1.9 KiB

577
latest/assets/documenter.css

@ -0,0 +1,577 @@
/*
* The default CSS style for Documenter.jl generated sites
*
* Heavily inspired by the Julia Sphinx theme
* https://github.com/JuliaLang/JuliaDoc
* which extends the sphinx_rtd_theme
* https://github.com/snide/sphinx_rtd_theme
*
* Part of Documenter.jl
* https://github.com/JuliaDocs/Documenter.jl
*
* License: MIT
*/
/* fonts */
body, input {
font-family: 'Lato', 'Helvetica Neue', Arial, sans-serif;
font-size: 16px;
color: #222;
text-rendering: optimizeLegibility;
}
pre, code, kbd {
font-family: 'Roboto Mono', Monaco, courier, monospace;
font-size: 0.90em;
}
pre code {
font-size: 1em;
}
a {
color: #2980b9;
text-decoration: none;
}
a:hover {
color: #3091d1;
}
a:visited {
color: #9b59b6;
}
body {
line-height: 1.5;
}
h1 {
font-size: 1.75em;
}
/* Unless the <h1> the is very first thing on the page (i.e. the second element
* in the <article>, * after the <header>, we add some additional styling to it
* to make it stand out a bit more. This way we get a reasonable fallback if CSS3
* selectors are not supported in the browser.
*/
article > h1:not(:nth-child(2)) {
margin: 2.5em 0 0;
padding-bottom: 0.30em;
border-bottom: 1px solid #e5e5e5;
}
h2 {
font-size: 1.50em;
margin: 2.3em 0 0;
padding-bottom: 0.25em;
border-bottom: 1px solid #e5e5e5;
}
h3 {
font-size: 1.25em;
margin: 2.0em 0 0;
}
h4 { font-size: 1.15em; }
h5 { font-size: 1.10em; }
h6 { font-size: 1em; }
h4, h5, h6 {
margin-top: 1.5em;
margin-bottom: 1em;
}
img {
max-width: 100%;
}
table {
border-collapse: collapse;
margin: 1em 0;
}
th, td {
border: 1px solid #e1e4e5;
padding: 0.5em 1em;
}
th {
border-bottom-width: 2px;
}
tr:nth-child(even) {
background-color: #f3f6f6;
}
hr {
border: 0;
border-top: 1px solid #e5e5e5;
}
/* Inline code and code blocks */
code {
padding: 0.1em;
background-color: rgba(0,0,0,.04);
border-radius: 3px;
}
pre {
background-color: #f5f5f5;
border: 1px solid #dddddd;
border-radius: 3px;
padding: 0.5em;
overflow: auto;
}
pre code {
padding: 0;
background-color: initial;
}
kbd {
font-size: 0.70em;
display: inline-block;
padding: 0.1em 0.5em 0.4em 0.5em;
line-height: 1.0em;
color: #444d56;
vertical-align: middle;
background-color: #fafbfc;
border: solid 1px #c6cbd1;
border-bottom-color: #959da5;
border-radius: 3px;
box-shadow: inset 0 -1px 0 #959da5;
}
/* Headers in admonitions and docstrings */
.admonition h1,
article section.docstring h1 {
font-size: 1.25em;
}
.admonition h2,
article section.docstring h2 {
font-size: 1.10em;
}
.admonition h3,
.admonition h4,
.admonition h5,
.admonition h6,
article section.docstring h3,
article section.docstring h4,
article section.docstring h5,
article section.docstring h6 {
font-size: 1em;
}
/* Navigation */
nav.toc {
position: fixed;
top: 0;
left: 0;
bottom: 0;
width: 20em;
overflow-y: auto;
padding: 1em 0;
background-color: #fcfcfc;
box-shadow: inset -14px 0px 5px -12px rgb(210,210,210);
}
nav.toc .logo {
margin: 0 auto;
display: block;
max-height: 6em;
max-width: 18em;
}
nav.toc h1 {
text-align: center;
margin-top: .57em;
margin-bottom: 0;
}
nav.toc select {
display: block;
height: 2em;
padding: 0 1.6em 0 1em;
min-width: 7em;
max-width: 90%;
max-width: calc(100% - 5em);
margin: 0 auto;
font-size: .83em;
border: 1px solid #c9c9c9;
border-radius: 1em;
/* TODO: doesn't seem to be centered on Safari */
text-align: center;
text-align-last: center;
appearance: none;
-moz-appearance: none;
-webkit-appearance: none;
background: white url("arrow.svg");
background-size: 1.155em;
background-repeat: no-repeat;
background-position: right;
}
nav.toc select:hover {
border: 1px solid #a0a0a0;
}
nav.toc select option {
text-align: center;
}
nav.toc input {
display: block;
height: 2em;
width: 90%;
width: calc(100% - 5em);
margin: 1.2em auto;
padding: 0 1em;
border: 1px solid #c9c9c9;
border-radius: 1em;
font-size: .83em;
}
nav.toc > ul * {
margin: 0;
}
nav.toc ul {
color: #404040;
padding: 0;
list-style: none;
}
nav.toc ul .toctext {
color: inherit;
display: block;
}
nav.toc ul a:hover {
color: #fcfcfc;
background-color: #4e4a4a;
}
nav.toc ul.internal a {
color: inherit;
display: block;
}
nav.toc ul.internal a:hover {
background-color: #d6d6d6;
}
nav.toc ul.internal {
background-color: #e3e3e3;
box-shadow: inset -14px 0px 5px -12px rgb(210,210,210);
list-style: none;
}
nav.toc ul.internal li.toplevel {
border-top: 1px solid #909090;
font-weight: bold;
}
nav.toc ul.internal li.toplevel:first-child {
border-top: none;
}
nav.toc .toctext {
padding-top: 0.3em;
padding-bottom: 0.3em;
padding-right: 1em;
}
nav.toc ul .toctext {
padding-left: 1em;
}
nav.toc ul ul .toctext {
padding-left: 2em;
}
nav.toc ul ul ul .toctext {
padding-left: 3em;
}
nav.toc li.current > .toctext {
border-top: 1px solid #c9c9c9;
border-bottom: 1px solid #c9c9c9;
color: #404040;
font-weight: bold;
background-color: white;
}
article {
margin-left: 20em;
min-width: 20em;
max-width: 48em;
padding: 2em;
}
article > header {}
article > header div#topbar {
display: none;
}
article > header nav ul {
display: inline-block;
list-style: none;
margin: 0;
padding: 0;
}
article > header nav li {
display: inline-block;
padding-right: 0.2em;
}
article > header nav li:before {
content: "»";
padding-right: 0.2em;
}
article > header .edit-page {
float: right;
}
article > footer {}
article > footer a.prev {
float: left;
}
article > footer a.next {
float: right;
}
article > footer a .direction:after {
content: ": ";
}
article hr {
margin: 1em 0;
}
article section.docstring {
border: 1px solid #ddd;
margin: 0.5em 0;
padding: 0.5em;
border-radius: 3px;
}
article section.docstring .docstring-header {
margin-bottom: 1em;
}
article section.docstring .docstring-binding {
color: #333;
font-weight: bold;
}
article section.docstring .docstring-category {
font-style: italic;
}
article section.docstring a.source-link {
display: block;
font-weight: bold;
}
.nav-anchor,
.nav-anchor:hover,
.nav-anchor:visited {
color: #333;
}
/*
* Admonitions
*
* Colors (title, body)
* warning: #f0b37e #ffedcc (orange)
* note: #6ab0de #e7f2fa (blue)
* tip: #1abc9c #dbfaf4 (green)
*/
.admonition {
border-radius: 3px;
background-color: #eeeeee;
}
.admonition-title {
border-radius: 3px 3px 0 0;
background-color: #9b9b9b;
padding: 0.15em 0.5em;
}
.admonition-text {
padding: 0.5em;
}
.admonition-text > :first-child {
margin-top: 0;
}
.admonition-text > :last-child {
margin-bottom: 0;
}
.admonition > .admonition-title:before {
font-family: "FontAwesome";
margin-right: 5px;
content: "\f06a";
}
.admonition.warning > .admonition-title {
background-color: #f0b37e;
}
.admonition.warning {
background-color: #ffedcc;
}
.admonition.note > .admonition-title {
background-color: #6ab0de;
}
.admonition.note {
background-color: #e7f2fa;
}
.admonition.tip > .admonition-title {
background-color: #1abc9c;
}
.admonition.tip {
background-color: #dbfaf4;
}
/* footnotes */
.footnote {
padding-left: 0.8em;
border-left: 2px solid #ccc;
}
/* Search page */
#search-results .category {
font-size: smaller;
}
#search-results .category:before {
content: " ";
}
/* Overriding the <code> block style of highligh.js.
* We have to override the padding and the background-color, since we style this
* part ourselves. Specifically, we style the <pre> surrounding the <code>, while
* highlight.js applies the .hljs style directly to the <code> tag.
*/
.hljs {
background-color: transparent;
padding: 0;
}
@media only screen and (max-width: 768px) {
nav.toc {
position: fixed;
overflow-y: scroll;
width: 16em;
left: -16em;
-webkit-overflow-scrolling: touch;
-webkit-transition-property: left; /* Safari */
-webkit-transition-duration: 0.3s; /* Safari */
transition-property: left;
transition-duration: 0.3s;
-webkit-transition-timing-function: ease-out; /* Safari */
transition-timing-function: ease-out;
z-index: 2;
}
nav.toc.show {
left: 0;
}
article {
margin-left: 0;
padding: 3em 0.9em 0 0.9em; /* top right bottom left */
overflow-wrap: break-word;
}
article > header {
position: fixed;
left: 0;
z-index: 1;
}
article > header nav, hr {
display: none;
}
article > header div#topbar {
display: block; /* is mobile */
position: fixed;
width: 100%;
height: 1.5em;
padding-top: 1em;
padding-bottom: 1em;
background-color: #fcfcfc;
box-shadow: 0 1px 3px rgba(0,0,0,.26);
top: 0;
-webkit-transition-property: top; /* Safari */
-webkit-transition-duration: 0.3s; /* Safari */
transition-property: top;
transition-duration: 0.3s;
}
article > header div#topbar.headroom--unpinned.headroom--not-top.headroom--not-bottom {
top: -4em;
-webkit-transition-property: top; /* Safari */
-webkit-transition-duration: 0.7s; /* Safari */
transition-property: top;
transition-duration: 0.7s;
}
article > header div#topbar span {
position: fixed;
width: 80%;
height: 1.5em;
margin-top: -0.1em;
margin-left: 0.9em;
font-size: 1.2em;
overflow: hidden;
}
article > header div#topbar a.fa-bars {
float: right;
padding: 0.6em;
margin-top: -0.6em;
margin-right: 0.3em;
font-size: 1.5em;
}
article > header div#topbar a.fa-bars:visited {
color: #3091d1;
}
article table {
overflow-x: auto;
display: block;
}
article div.MathJax_Display {
overflow: scroll;
}
article span.MathJax {
overflow: hidden;
}
}
@media only screen and (max-width: 320px) {
body {
font-size: 15px;
}
}

129
latest/assets/documenter.js

@ -0,0 +1,129 @@
/*
* Part of Documenter.jl
* https://github.com/JuliaDocs/Documenter.jl
*
* License: MIT
*/
requirejs.config({
paths: {
'jquery': 'https://cdnjs.cloudflare.com/ajax/libs/jquery/3.1.1/jquery.min',
'jqueryui': 'https://cdnjs.cloudflare.com/ajax/libs/jqueryui/1.12.0/jquery-ui.min',
'headroom': 'https://cdnjs.cloudflare.com/ajax/libs/headroom/0.9.3/headroom.min',
'mathjax': 'https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS_HTML',
'highlight': 'https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min',
'highlight-julia': 'https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/languages/julia.min',
'highlight-julia-repl': 'https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/languages/julia-repl.min',
},
shim: {
'mathjax' : {
exports: "MathJax"
},
'highlight-julia': ['highlight'],
'highlight-julia-repl': ['highlight'],
}
});
// Load MathJax
require(['mathjax'], function(MathJax) {
MathJax.Hub.Config({
"tex2jax": {
inlineMath: [['$','$'], ['\\(','\\)']],
processEscapes: true
}
});
MathJax.Hub.Config({
config: ["MMLorHTML.js"],
jax: [
"input/TeX",
"output/HTML-CSS",
"output/NativeMML"
],
extensions: [
"MathMenu.js",
"MathZoom.js",
"TeX/AMSmath.js",
"TeX/AMSsymbols.js",
"TeX/autobold.js",
"TeX/autoload-all.js"
]
});
MathJax.Hub.Config({
TeX: { equationNumbers: { autoNumber: "AMS" } }
});
})
require(['jquery', 'highlight', 'highlight-julia', 'highlight-julia-repl'], function($, hljs) {
$(document).ready(function() {
hljs.initHighlighting();
})
})
// update the version selector with info from the siteinfo.js and ../versions.js files
require(['jquery'], function($) {
$(document).ready(function() {
var version_selector = $("#version-selector");
// add the current version to the selector based on siteinfo.js, but only if the selector is empty
if (typeof DOCUMENTER_CURRENT_VERSION !== 'undefined' && $('#version-selector > option').length == 0) {
var option = $("<option value='#' selected='selected'>" + DOCUMENTER_CURRENT_VERSION + "</option>");
version_selector.append(option);
}
if (typeof DOC_VERSIONS !== 'undefined') {
var existing_versions = $('#version-selector > option');
var existing_versions_texts = existing_versions.map(function(i,x){return x.text});
DOC_VERSIONS.forEach(function(each) {
var version_url = documenterBaseURL + "/../" + each;
var existing_id = $.inArray(each, existing_versions_texts);
// if not already in the version selector, add it as a new option,
// otherwise update the old option with the URL and enable it
if (existing_id == -1) {
var option = $("<option value='" + version_url + "'>" + each + "</option>");
version_selector.append(option);
} else {
var option = existing_versions[existing_id];
option.value = version_url;
option.disabled = false;
}
});
}
// only show the version selector if the selector has been populated
if ($('#version-selector > option').length > 0) {
version_selector.css("visibility", "visible");
}
})
})
// mobile
require(['jquery', 'headroom'], function($, Headroom) {
$(document).ready(function() {
var navtoc = $("nav.toc");
$("nav.toc li.current a.toctext").click(function() {
navtoc.toggleClass('show');
});
$("article > header div#topbar a.fa-bars").click(function(ev) {
ev.preventDefault();
navtoc.toggleClass('show');
if (navtoc.hasClass('show')) {
var title = $("article > header div#topbar span").text();
$("nav.toc ul li a:contains('" + title + "')").focus();
}
});
$("article#docs").bind('click', function(ev) {
if ($(ev.target).is('div#topbar a.fa-bars')) {
return;
}
if (navtoc.hasClass('show')) {
navtoc.removeClass('show');
}
});
if ($("article > header div#topbar").css('display') == 'block') {
var headroom = new Headroom(document.querySelector("article > header div#topbar"), {"tolerance": {"up": 10, "down": 10}});
headroom.init();
}
})
})

243
latest/assets/search.js

@ -0,0 +1,243 @@
/*
* Part of Documenter.jl
* https://github.com/JuliaDocs/Documenter.jl
*
* License: MIT
*/
// parseUri 1.2.2
// (c) Steven Levithan <stevenlevithan.com>
// MIT License
function parseUri (str) {
var o = parseUri.options,
m = o.parser[o.strictMode ? "strict" : "loose"].exec(str),
uri = {},
i = 14;
while (i--) uri[o.key[i]] = m[i] || "";
uri[o.q.name] = {};
uri[o.key[12]].replace(o.q.parser, function ($0, $1, $2) {
if ($1) uri[o.q.name][$1] = $2;
});
return uri;
};
parseUri.options = {
strictMode: false,
key: ["source","protocol","authority","userInfo","user","password","host","port","relative","path","directory","file","query","anchor"],
q: {
name: "queryKey",
parser: /(?:^|&)([^&=]*)=?([^&]*)/g
},
parser: {
strict: /^(?:([^:\/?#]+):)?(?:\/\/((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?))?((((?:[^?#\/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/,
loose: /^(?:(?![^:@]+:[^:@\/]*@)([^:\/?#.]+):)?(?:\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/
}
};
requirejs.config({
paths: {
'jquery': 'https://cdnjs.cloudflare.com/ajax/libs/jquery/3.1.1/jquery.min',
'lunr': 'https://cdnjs.cloudflare.com/ajax/libs/lunr.js/2.1.3/lunr.min',
'lodash': 'https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.min',
}
});
var currentScript = document.currentScript;
require(["jquery", "lunr", "lodash"], function($, lunr, _) {
$("#search-form").submit(function(e) {
e.preventDefault()
})
// list below is the lunr 2.1.3 list minus the intersect with names(Base)
// (all, any, get, in, is, which) and (do, else, for, let, where, while, with)
// ideally we'd just filter the original list but it's not available as a variable
lunr.stopWordFilter = lunr.generateStopWordFilter([
'a',
'able',
'about',
'across',
'after',
'almost',
'also',
'am',
'among',
'an',
'and',
'are',
'as',
'at',
'be',
'because',
'been',
'but',
'by',
'can',
'cannot',
'could',
'dear',
'did',
'does',
'either',
'ever',
'every',
'from',
'got',
'had',
'has',
'have',
'he',
'her',
'hers',
'him',
'his',
'how',
'however',
'i',
'if',
'into',
'it',
'its',
'just',
'least',
'like',
'likely',
'may',
'me',
'might',
'most',
'must',
'my',
'neither',
'no',
'nor',
'not',
'of',
'off',
'often',
'on',
'only',
'or',
'other',
'our',
'own',
'rather',
'said',
'say',
'says',
'she',
'should',
'since',
'so',
'some',
'than',
'that',
'the',
'their',
'them',
'then',
'there',
'these',
'they',
'this',
'tis',
'to',
'too',
'twas',
'us',
'wants',
'was',
'we',
'were',
'what',
'when',
'who',
'whom',
'why',
'will',
'would',
'yet',
'you',
'your'
])
// add . as a separator, because otherwise "title": "Documenter.Anchors.add!"
// would not find anything if searching for "add!", only for the entire qualification
lunr.tokenizer.separator = /[\s\-\.]+/
// custom trimmer that doesn't strip @ and !, which are used in julia macro and function names
lunr.trimmer = function (token) {
return token.update(function (s) {
return s.replace(/^[^a-zA-Z0-9@!]+/, '').replace(/[^a-zA-Z0-9@!]+$/, '')
})
}
lunr.Pipeline.registerFunction(lunr.stopWordFilter, 'juliaStopWordFilter')
lunr.Pipeline.registerFunction(lunr.trimmer, 'juliaTrimmer')
var index = lunr(function () {
this.ref('location')
this.field('title')
this.field('text')
documenterSearchIndex['docs'].forEach(function(e) {
this.add(e)
}, this)
})
var store = {}
documenterSearchIndex['docs'].forEach(function(e) {
store[e.location] = {title: e.title, category: e.category}
})
$(function(){
function update_search(querystring) {
tokens = lunr.tokenizer(querystring)
results = index.query(function (q) {
tokens.forEach(function (t) {
q.term(t.toString(), {
fields: ["title"],
boost: 10,
usePipeline: false,
editDistance: 2,
wildcard: lunr.Query.wildcard.NONE
})
q.term(t.toString(), {
fields: ["text"],
boost: 1,
usePipeline: true,
editDistance: 2,
wildcard: lunr.Query.wildcard.NONE
})
})
})
$('#search-info').text("Number of results: " + results.length)
$('#search-results').empty()
results.forEach(function(result) {
data = store[result.ref]
link = $('<a>')
link.text(data.title)
link.attr('href', documenterBaseURL+'/'+result.ref)
cat = $('<span class="category">('+data.category+')</span>')
li = $('<li>').append(link).append(cat)
$('#search-results').append(li)
})
}
function update_search_box() {
querystring = $('#search-query').val()
update_search(querystring)
}
$('#search-query').keyup(_.debounce(update_search_box, 250))
$('#search-query').change(update_search_box)
search_query_uri = parseUri(window.location).queryKey["q"]
if(search_query_uri !== undefined) {
search_query = decodeURIComponent(search_query_uri.replace(/\+/g, '%20'))
$("#search-query").val(search_query)
}
update_search_box();
})
})

8
latest/customprocessing.html

@ -0,0 +1,8 @@
<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"/><meta name="viewport" content="width=device-width, initial-scale=1.0"/><title>5. Custom pre- and post-processing · Examples.jl</title><link href="https://cdnjs.cloudflare.com/ajax/libs/normalize/4.2.0/normalize.min.css" rel="stylesheet" type="text/css"/><link href="https://fonts.googleapis.com/css?family=Lato|Roboto+Mono" rel="stylesheet" type="text/css"/><link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.6.3/css/font-awesome.min.css" rel="stylesheet" type="text/css"/><link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/default.min.css" rel="stylesheet" type="text/css"/><script>documenterBaseURL="."</script><script src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.2.0/require.min.js" data-main="assets/documenter.js"></script><script src="siteinfo.js"></script><script src="../versions.js"></script><link href="assets/documenter.css" rel="stylesheet" type="text/css"/></head><body><nav class="toc"><h1>Examples.jl</h1><select id="version-selector" onChange="window.location.href=this.value" style="visibility: hidden"></select><form class="search" id="search-form" action="search.html"><input id="search-query" name="q" type="text" placeholder="Search docs"/></form><ul><li><a class="toctext" href="index.html"><strong>1.</strong> Introduction</a></li><li><a class="toctext" href="fileformat.html"><strong>2.</strong> File Format</a></li><li><a class="toctext" href="pipeline.html"><strong>3.</strong> Processing pipeline</a></li><li><a class="toctext" href="outputformats.html"><strong>4.</strong> Output formats</a></li><li class="current"><a class="toctext" href="customprocessing.html"><strong>5.</strong> Custom pre- and post-processing</a><ul class="internal"></ul></li><li><a class="toctext" href="documenter.html"><strong>6.</strong> Interaction with Documenter.jl</a></li><li><a class="toctext" href="generated/example.html"><strong>7.</strong> Example</a></li></ul></nav><article id="docs"><header><nav><ul><li><a href="customprocessing.html"><strong>5.</strong> Custom pre- and post-processing</a></li></ul><a class="edit-page" href="https://github.com/fredrikekre/Examples.jl/blob/master/docs/src/customprocessing.md"><span class="fa"></span> Edit on GitHub</a></nav><hr/><div id="topbar"><span>5. Custom pre- and post-processing</span><a class="fa fa-bars" href="#"></a></div></header><h1><a class="nav-anchor" id="Custom-pre-and-post-processing-1" href="#Custom-pre-and-post-processing-1"><strong>5.</strong> Custom pre- and post-processing</a></h1><p>Since all packages are different, and may have different demands on how to create a nice example for the documentation it is important that the package maintainer does not feel limited by the by default provided syntax that this package offers. While you can generally come a long way by utilizing <a href="fileformat.html#Filtering-lines-1">line filtering</a> there might be situations where you need to manually hook into the generation and change things. In <code>Examples.jl</code> this is done by letting the user supply custom pre- and post-processing functions that may do transformation of the content.</p><p>All of the generators (<a href="outputformats.html#Examples.markdown"><code>Examples.markdown</code></a>, <a href="outputformats.html#Examples.notebook"><code>Examples.notebook</code></a> and <a href="outputformats.html#Examples.script"><code>Examples.script</code></a>) accepts <code>preprocess</code> and <code>postprocess</code> keyword arguments. The default &quot;transformation&quot; is the <code>identity</code> function. The input to the transformation functions is a <code>String</code>, and the output should be the transformed <code>String</code>.</p><p><code>preprocess</code> is sent the raw input that is read from the source file (<a href="pipeline.html#Pre-processing-1">modulo the default line ending transformation</a>). <code>postprocess</code> is given different things depending on the output: For markdown and script output <code>postprocess</code> is given the content <code>String</code> just before writing it to the output file, but for notebook output <code>postprocess</code> is given the dictionary representing the notebook, since, in general, this is more useful.</p><p>As an example, lets say we want to splice the date of generation into the output. We could of course update our source file before generating the docs, but we could instead use a <code>preprocess</code> function that splices the date into the source for us. Consider the following source file:</p><pre><code class="language-julia">#&#39; # Example
#&#39; This example was generated DATEOFTODAY
x = 1 // 3</code></pre><p>where <code>DATEOFTODAY</code> is a placeholder, to make it easier for our <code>preprocess</code> function to find the location. Now, lets define the <code>preprocess</code> function, for example</p><pre><code class="language-julia">function update_date(content)
content = replace(content, &quot;DATEOFTODAY&quot; =&gt; Date(now()))
return content
end</code></pre><p>which would replace every occurrence of <code>&quot;DATEOFTODAY&quot;</code> with the current date. We would now simply give this function to the generator, for example:</p><pre><code class="language-julia">Examples.markdown(&quot;input.jl&quot;, &quot;outputdir&quot;; preprocess = update_date)</code></pre><footer><hr/><a class="previous" href="outputformats.html"><span class="direction">Previous</span><span class="title"><strong>4.</strong> Output formats</span></a><a class="next" href="documenter.html"><span class="direction">Next</span><span class="title"><strong>6.</strong> Interaction with Documenter.jl</span></a></footer></article></body></html>

2
latest/documenter.html

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"/><meta name="viewport" content="width=device-width, initial-scale=1.0"/><title>6. Interaction with Documenter.jl · Examples.jl</title><link href="https://cdnjs.cloudflare.com/ajax/libs/normalize/4.2.0/normalize.min.css" rel="stylesheet" type="text/css"/><link href="https://fonts.googleapis.com/css?family=Lato|Roboto+Mono" rel="stylesheet" type="text/css"/><link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.6.3/css/font-awesome.min.css" rel="stylesheet" type="text/css"/><link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/default.min.css" rel="stylesheet" type="text/css"/><script>documenterBaseURL="."</script><script src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.2.0/require.min.js" data-main="assets/documenter.js"></script><script src="siteinfo.js"></script><script src="../versions.js"></script><link href="assets/documenter.css" rel="stylesheet" type="text/css"/></head><body><nav class="toc"><h1>Examples.jl</h1><select id="version-selector" onChange="window.location.href=this.value" style="visibility: hidden"></select><form class="search" id="search-form" action="search.html"><input id="search-query" name="q" type="text" placeholder="Search docs"/></form><ul><li><a class="toctext" href="index.html"><strong>1.</strong> Introduction</a></li><li><a class="toctext" href="fileformat.html"><strong>2.</strong> File Format</a></li><li><a class="toctext" href="pipeline.html"><strong>3.</strong> Processing pipeline</a></li><li><a class="toctext" href="outputformats.html"><strong>4.</strong> Output formats</a></li><li><a class="toctext" href="customprocessing.html"><strong>5.</strong> Custom pre- and post-processing</a></li><li class="current"><a class="toctext" href="documenter.html"><strong>6.</strong> Interaction with Documenter.jl</a><ul class="internal"></ul></li><li><a class="toctext" href="generated/example.html"><strong>7.</strong> Example</a></li></ul></nav><article id="docs"><header><nav><ul><li><a href="documenter.html"><strong>6.</strong> Interaction with Documenter.jl</a></li></ul><a class="edit-page" href="https://github.com/fredrikekre/Examples.jl/blob/master/docs/src/documenter.md"><span class="fa"></span> Edit on GitHub</a></nav><hr/><div id="topbar"><span>6. Interaction with Documenter.jl</span><a class="fa fa-bars" href="#"></a></div></header><h1><a class="nav-anchor" id="Interaction-with-Documenter-1" href="#Interaction-with-Documenter-1"><strong>6.</strong> Interaction with Documenter.jl</a></h1><p>TBW</p><footer><hr/><a class="previous" href="customprocessing.html"><span class="direction">Previous</span><span class="title"><strong>5.</strong> Custom pre- and post-processing</span></a><a class="next" href="generated/example.html"><span class="direction">Next</span><span class="title"><strong>7.</strong> Example</span></a></footer></article></body></html>

47
latest/fileformat.html

@ -0,0 +1,47 @@
<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"/><meta name="viewport" content="width=device-width, initial-scale=1.0"/><title>2. File Format · Examples.jl</title><link href="https://cdnjs.cloudflare.com/ajax/libs/normalize/4.2.0/normalize.min.css" rel="stylesheet" type="text/css"/><link href="https://fonts.googleapis.com/css?family=Lato|Roboto+Mono" rel="stylesheet" type="text/css"/><link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.6.3/css/font-awesome.min.css" rel="stylesheet" type="text/css"/><link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/default.min.css" rel="stylesheet" type="text/css"/><script>documenterBaseURL="."</script><script src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.2.0/require.min.js" data-main="assets/documenter.js"></script><script src="siteinfo.js"></script><script src="../versions.js"></script><link href="assets/documenter.css" rel="stylesheet" type="text/css"/></head><body><nav class="toc"><h1>Examples.jl</h1><select id="version-selector" onChange="window.location.href=this.value" style="visibility: hidden"></select><form class="search" id="search-form" action="search.html"><input id="search-query" name="q" type="text" placeholder="Search docs"/></form><ul><li><a class="toctext" href="index.html"><strong>1.</strong> Introduction</a></li><li class="current"><a class="toctext" href="fileformat.html"><strong>2.</strong> File Format</a><ul class="internal"><li><a class="toctext" href="#Syntax-1"><strong>2.1.</strong> Syntax</a></li><li><a class="toctext" href="#Filtering-lines-1"><strong>2.2.</strong> Filtering Lines</a></li></ul></li><li><a class="toctext" href="pipeline.html"><strong>3.</strong> Processing pipeline</a></li><li><a class="toctext" href="outputformats.html"><strong>4.</strong> Output formats</a></li><li><a class="toctext" href="customprocessing.html"><strong>5.</strong> Custom pre- and post-processing</a></li><li><a class="toctext" href="documenter.html"><strong>6.</strong> Interaction with Documenter.jl</a></li><li><a class="toctext" href="generated/example.html"><strong>7.</strong> Example</a></li></ul></nav><article id="docs"><header><nav><ul><li><a href="fileformat.html"><strong>2.</strong> File Format</a></li></ul><a class="edit-page" href="https://github.com/fredrikekre/Examples.jl/blob/master/docs/src/fileformat.md"><span class="fa"></span> Edit on GitHub</a></nav><hr/><div id="topbar"><span>2. File Format</span><a class="fa fa-bars" href="#"></a></div></header><h1><a class="nav-anchor" id="**2.**-File-Format-1" href="#**2.**-File-Format-1"><strong>2.</strong> File Format</a></h1><p>The source file format for <code>Examples.jl</code> is a regular, commented, julia (<code>.jl</code>) scripts. The idea is that the scripts also serve as documentation on their own and it is also simple to include them in the test-suite, with e.g. <code>include</code>, to make sure the examples stay up do date with other changes in your package.</p><h2><a class="nav-anchor" id="Syntax-1" href="#Syntax-1"><strong>2.1.</strong> Syntax</a></h2><p>The basic syntax is simple:</p><ul><li>lines starting with <code>#&#39;</code> is treated as markdown,</li><li>all other lines are treated as julia code.</li></ul><p>The reason for using <code>#&#39;</code> instead of <code>#</code> is that we want to be able to use <code>#</code> as comments, just as in a regular script. Lets look at a simple example:</p><pre><code class="language-julia">#&#39; # Rational numbers
#&#39;
#&#39; In julia rational numbers can be constructed with the `//` operator.
#&#39; Lets define two rational numbers, `x` and `y`:
x = 1//3
y = 2//5
#&#39; When adding `x` and `y` together we obtain a new rational number:
z = x + y</code></pre><p>In the lines <code>#&#39;</code> we can use regular markdown syntax, for example the <code>#</code> used for the heading and the backticks for formatting code. The other lines are regular julia code. We note a couple of things:</p><ul><li>The script is valid julia, which means that we can <code>include</code> it and the example will run</li><li>The script is &quot;self-explanatory&quot;, i.e. the markdown lines works as comments and thus serve as good documentation on its own.</li></ul><p>For simple use this is all you need to know, the script above is valid. Let&#39;s take a look at what the above snippet would generate, with default settings:</p><ul><li><p><a href="outputformats.html#Examples.markdown"><code>Examples.markdown</code></a>: leading <code>#&#39;</code> are removed, and code lines are wrapped in <code>@example</code>-blocks:</p><pre><code class="language-markdown"># Rational numbers
In julia rational numbers can be constructed with the `//` operator.
Lets define two rational numbers, `x` and `y`:
```@example filename
x = 1//3
y = 2//5
```
When adding `x` and `y` together we obtain a new rational number:
```@example filename
z = x + y
```</code></pre></li><li><p><a href="outputformats.html#Examples.notebook"><code>Examples.notebook</code></a>: leading <code>#&#39;</code> are removed, markdown lines are placed in <code>&quot;markdown&quot;</code> cells, and code lines in <code>&quot;code&quot;</code> cells:</p><pre><code class="language-none"> │ # Rational numbers
│ In julia rational numbers can be constructed with the `//` operator.
│ Lets define two rational numbers, `x` and `y`:
In [1]: │ x = 1//3
│ y = 2//5
Out [1]: │ 2//5
│ When adding `x` and `y` together we obtain a new rational number:
In [2]: │ z = x + y
Out [2]: │ 11//15</code></pre></li><li><p><a href="outputformats.html#Examples.script"><code>Examples.script</code></a>: all lines starting with <code>#&#39;</code> are removed:</p><pre><code class="language-julia">x = 1//3
y = 2//5
z = x + y</code></pre></li></ul><h2><a class="nav-anchor" id="Filtering-lines-1" href="#Filtering-lines-1"><strong>2.2.</strong> Filtering Lines</a></h2><p>It is possible to filter out lines depending on the output format. For this purpose, there are three different &quot;tokens&quot; that can be placed on the start of the line:</p><ul><li><code>#md</code>: markdown output only,</li><li><code>#nb</code>: notebook output only,</li><li><code>#jl</code>: script output only.</li></ul><p>Lines starting with one of these tokens are filtered out in the <a href="pipeline.html#Pre-processing-1">preprocessing step</a>.</p><p>Suppose, for example, that we want to include a docstring within a <code>@docs</code> block using Documenter. Obviously we don&#39;t want to include this in the notebook, since <code>@docs</code> is Documenter syntax that the notebook will not understand. This is a case where we can prepend <code>#md</code> to those lines:</p><pre><code class="language-julia">#md #&#39; ```@docs
#md #&#39; Examples.markdown
#md #&#39; Examples.notebook
#md #&#39; Examples.markdown
#md #&#39; ```</code></pre><p>The lines in the example above would be filtered out in the preprocessing step, unless we are generating a markdown file. When generating a markdown file we would simple remove the leading <code>#md</code> from the lines. Beware that the space after the tag is also removed.</p><footer><hr/><a class="previous" href="index.html"><span class="direction">Previous</span><span class="title"><strong>1.</strong> Introduction</span></a><a class="next" href="pipeline.html"><span class="direction">Next</span><span class="title"><strong>3.</strong> Processing pipeline</span></a></footer></article></body></html>

3
latest/generated/example.html

@ -0,0 +1,3 @@
<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"/><meta name="viewport" content="width=device-width, initial-scale=1.0"/><title>7. Example · Examples.jl</title><link href="https://cdnjs.cloudflare.com/ajax/libs/normalize/4.2.0/normalize.min.css" rel="stylesheet" type="text/css"/><link href="https://fonts.googleapis.com/css?family=Lato|Roboto+Mono" rel="stylesheet" type="text/css"/><link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.6.3/css/font-awesome.min.css" rel="stylesheet" type="text/css"/><link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/default.min.css" rel="stylesheet" type="text/css"/><script>documenterBaseURL=".."</script><script src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.2.0/require.min.js" data-main="../assets/documenter.js"></script><script src="../siteinfo.js"></script><script src="../../versions.js"></script><link href="../assets/documenter.css" rel="stylesheet" type="text/css"/></head><body><nav class="toc"><h1>Examples.jl</h1><select id="version-selector" onChange="window.location.href=this.value" style="visibility: hidden"></select><form class="search" id="search-form" action="../search.html"><input id="search-query" name="q" type="text" placeholder="Search docs"/></form><ul><li><a class="toctext" href="../index.html"><strong>1.</strong> Introduction</a></li><li><a class="toctext" href="../fileformat.html"><strong>2.</strong> File Format</a></li><li><a class="toctext" href="../pipeline.html"><strong>3.</strong> Processing pipeline</a></li><li><a class="toctext" href="../outputformats.html"><strong>4.</strong> Output formats</a></li><li><a class="toctext" href="../customprocessing.html"><strong>5.</strong> Custom pre- and post-processing</a></li><li><a class="toctext" href="../documenter.html"><strong>6.</strong> Interaction with Documenter.jl</a></li><li class="current"><a class="toctext" href="example.html"><strong>7.</strong> Example</a><ul class="internal"><li><a class="toctext" href="#Rational-numbers-in-Julia-1">Rational numbers in Julia</a></li></ul></li></ul></nav><article id="docs"><header><nav><ul><li><a href="example.html"><strong>7.</strong> Example</a></li></ul><a class="edit-page" href="https://github.com/fredrikekre/Examples.jl/blob/master/docs/src/generated/example.md"><span class="fa"></span> Edit on GitHub</a></nav><hr/><div id="topbar"><span>7. Example</span><a class="fa fa-bars" href="#"></a></div></header><h1><a class="nav-anchor" id="**7.**-Example-1" href="#**7.**-Example-1"><strong>7.</strong> Example</a></h1><p><em>Output generated with Examples.jl based on <a href="../../../examples/example.jl">this</a> source file.</em></p><p>This is an example source file for input to Examples.jl.</p><p>If you are reading this you are seeing the markdown output generated from the source file, here you can see the corresponding notebook output: <a href="example.ipynb">example.ipynb</a></p><h2><a class="nav-anchor" id="Rational-numbers-in-Julia-1" href="#Rational-numbers-in-Julia-1">Rational numbers in Julia</a></h2><p>Rational number in julia can be constructed with the <code>//</code> operator:</p><div><pre><code class="language-julia">x = 1//3
y = 2//5</code></pre><pre><code class="language-none">2//5</code></pre></div><p>Operations with rational number returns a new rational number</p><div><pre><code class="language-julia">x + y</code></pre><pre><code class="language-none">11//15</code></pre></div><div><pre><code class="language-julia">x * y</code></pre><pre><code class="language-none">2//15</code></pre></div><p>Everytime a rational number is constructed, it will be simplified using the <code>gcd</code> function, for example <code>2//4</code> simplifies to <code>1//2</code>:</p><div><pre><code class="language-julia">2//4</code></pre><pre><code class="language-none">1//2</code></pre></div><p>and <code>2//4 + 2//4</code> simplifies to <code>1//1</code>:</p><div><pre><code class="language-julia">2//4 + 2//4</code></pre><pre><code class="language-none">1//1</code></pre></div><footer><hr/><a class="previous" href="../documenter.html"><span class="direction">Previous</span><span class="title"><strong>6.</strong> Interaction with Documenter.jl</span></a></footer></article></body></html>

116
latest/generated/example.ipynb

@ -0,0 +1,116 @@
{
"cells": [
{
"outputs": [],
"cell_type": "markdown",
"source": [
"# **7.** Example\n",
"\n",
"*Output generated with Examples.jl based on\n",
"[this](../../../examples/example.jl) source file.*\n",
"\n",
"This is an example source file for input to Examples.jl.\n",
"\n",
"If you are reading this you are seeing the notebook output\n",
"generated from the source file, here you can see the corresponding\n",
"markdown output: [example.md](./example.md)"
],
"metadata": {}
},
{
"outputs": [],
"cell_type": "markdown",
"source": [
"## Rational numbers in Julia\n",
"Rational number in julia can be constructed with the `//` operator:"
],
"metadata": {}
},
{
"outputs": [],
"cell_type": "code",
"source": [
"x = 1//3\n",
"y = 2//5"
],
"metadata": {},
"execution_count": null
},
{
"outputs": [],
"cell_type": "markdown",
"source": [
"Operations with rational number returns a new rational number"
],
"metadata": {}
},
{
"outputs": [],
"cell_type": "code",
"source": [
"x + y"
],
"metadata": {},
"execution_count": null
},
{
"outputs": [],
"cell_type": "code",
"source": [
"x * y"
],
"metadata": {},
"execution_count": null
},
{
"outputs": [],
"cell_type": "markdown",
"source": [
"Everytime a rational number is constructed, it will be simplified\n",
"using the `gcd` function, for example `2//4` simplifies to `1//2`:"
],
"metadata": {}
},
{
"outputs": [],
"cell_type": "code",
"source": [
"2//4"
],
"metadata": {},
"execution_count": null
},
{
"outputs": [],
"cell_type": "markdown",
"source": [
"and `2//4 + 2//4` simplifies to `1//1`:"
],
"metadata": {}
},
{
"outputs": [],
"cell_type": "code",
"source": [
"2//4 + 2//4"
],
"metadata": {},
"execution_count": null
}
],
"nbformat_minor": 3,
"metadata": {
"language_info": {
"file_extension": ".jl",
"mimetype": "application/julia",
"name": "julia",
"version": "0.7.0"
},
"kernelspec": {
"name": "julia-0.7",
"display_name": "Julia 0.7.0",
"language": "julia"
}
},
"nbformat": 4
}

11
latest/generated/example.jl

@ -0,0 +1,11 @@
x = 1//3
y = 2//5
x + y
x * y
2//4
2//4 + 2//4

2
latest/index.html

File diff suppressed because one or more lines are too long

20
latest/outputformats.html

@ -0,0 +1,20 @@
<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"/><meta name="viewport" content="width=device-width, initial-scale=1.0"/><title>4. Output formats · Examples.jl</title><link href="https://cdnjs.cloudflare.com/ajax/libs/normalize/4.2.0/normalize.min.css" rel="stylesheet" type="text/css"/><link href="https://fonts.googleapis.com/css?family=Lato|Roboto+Mono" rel="stylesheet" type="text/css"/><link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.6.3/css/font-awesome.min.css" rel="stylesheet" type="text/css"/><link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/default.min.css" rel="stylesheet" type="text/css"/><script>documenterBaseURL="."</script><script src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.2.0/require.min.js" data-main="assets/documenter.js"></script><script src="siteinfo.js"></script><script src="../versions.js"></script><link href="assets/documenter.css" rel="stylesheet" type="text/css"/></head><body><nav class="toc"><h1>Examples.jl</h1><select id="version-selector" onChange="window.location.href=this.value" style="visibility: hidden"></select><form class="search" id="search-form" action="search.html"><input id="search-query" name="q" type="text" placeholder="Search docs"/></form><ul><li><a class="toctext" href="index.html"><strong>1.</strong> Introduction</a></li><li><a class="toctext" href="fileformat.html"><strong>2.</strong> File Format</a></li><li><a class="toctext" href="pipeline.html"><strong>3.</strong> Processing pipeline</a></li><li class="current"><a class="toctext" href="outputformats.html"><strong>4.</strong> Output formats</a><ul class="internal"><li><a class="toctext" href="#Markdown-output-1"><strong>4.1.</strong> Markdown output</a></li><li><a class="toctext" href="#Notebook-output-1"><strong>4.2.</strong> Notebook output</a></li><li><a class="toctext" href="#Script-output-1"><strong>4.3.</strong> Script output</a></li></ul></li><li><a class="toctext" href="customprocessing.html"><strong>5.</strong> Custom pre- and post-processing</a></li><li><a class="toctext" href="documenter.html"><strong>6.</strong> Interaction with Documenter.jl</a></li><li><a class="toctext" href="generated/example.html"><strong>7.</strong> Example</a></li></ul></nav><article id="docs"><header><nav><ul><li><a href="outputformats.html"><strong>4.</strong> Output formats</a></li></ul><a class="edit-page" href="https://github.com/fredrikekre/Examples.jl/blob/master/docs/src/outputformats.md"><span class="fa"></span> Edit on GitHub</a></nav><hr/><div id="topbar"><span>4. Output formats</span><a class="fa fa-bars" href="#"></a></div></header><h1><a class="nav-anchor" id="Output-formats-1" href="#Output-formats-1"><strong>4.</strong> Output formats</a></h1><h2><a class="nav-anchor" id="Markdown-output-1" href="#Markdown-output-1"><strong>4.1.</strong> Markdown output</a></h2><pre><code class="language-none">#&#39; # Markdown ┐
#&#39;
#&#39; This line is treated as markdown, since it starts with #&#39;
#&#39; The leading #&#39; (including the space) is removed ┘
#&#39; Here is an example with some code ]
x = sin.(cos.([1, 2, 3])) ┐
y = x.^2 - x ┘</code></pre><p>By default, <code>CodeChunks</code> written to Documenter <code>@example</code> blocks. For example, the code above would result in the following markdown:</p><pre><code class="language-markdown"># Markdown
This line is treated as markdown, since it starts with #&#39;
The leading #&#39; (including the space) is removed
Here is an example with some code
```@example
x = sin.(cos.([1, 2, 3]))
y = x.^2 - x
```</code></pre><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Examples.markdown" href="#Examples.markdown"><code>Examples.markdown</code></a><span class="docstring-category">Function</span>.</div><div><div><pre><code class="language-none">Examples.markdown(inputfile, outputdir; kwargs...)</code></pre><p>Generate a markdown file from <code>inputfile</code> and write the result to the directory<code>outputdir</code>.</p><p>Keyword arguments:</p><ul><li><code>name</code>: name of the output file, excluding <code>.md</code>. <code>name</code> is also used to name all the <code>@example</code> blocks. Defaults to the filename of <code>inputfile</code>.</li><li><code>preprocess</code>, <code>postprocess</code>: custom pre- and post-processing functions, see the <a href="customprocessing.html#Custom-pre-and-post-processing-1">Custom pre- and post-processing</a> section of the manual. Defaults to <code>identity</code>.</li><li><code>codefence</code>: A <code>Pair</code> of opening and closing code fence. Defaults to<pre><code class="language-none">&quot;```@example $(name)&quot; =&gt; &quot;```&quot;</code></pre></li><li><code>documenter</code>: boolean that says if the output is intended to use with Documenter.jl. Defaults to <code>false</code>. See the the manual section on <a href="documenter.html#Interaction-with-Documenter-1">Interaction with Documenter</a>.</li></ul></div></div><a class="source-link" target="_blank" href="https://github.com/fredrikekre/Examples.jl/blob/e0d090e4ed7f4310b1007bffbce0f65196d08f37/src/Examples.jl#L160-L179">source</a></section><h2><a class="nav-anchor" id="Notebook-output-1" href="#Notebook-output-1"><strong>4.2.</strong> Notebook output</a></h2><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Examples.notebook" href="#Examples.notebook"><code>Examples.notebook</code></a><span class="docstring-category">Function</span>.</div><div><div><pre><code class="language-none">Examples.notebook(inputfile, outputdir; kwargs...)</code></pre><p>Generate a notebook from <code>inputfile</code> and write the result to <code>outputdir</code>.</p><p>Keyword arguments:</p><ul><li><code>name</code>: name of the output file, excluding <code>.ipynb</code>. Defaults to the filename of <code>inputfile</code>.</li><li><code>preprocess</code>, <code>postprocess</code>: custom pre- and post-processing functions, see the <a href="customprocessing.html#Custom-pre-and-post-processing-1">Custom pre- and post-processing</a> section of the manual. Defaults to <code>identity</code>.</li><li><code>execute</code>: a boolean deciding if the generated notebook should also be executed or not. Defaults to <code>false</code>.</li><li><code>documenter</code>: boolean that says if the source contains Documenter.jl specific things to filter out during notebook generation. Defaults to <code>false</code>. See the the manual section on <a href="documenter.html#Interaction-with-Documenter-1">Interaction with Documenter</a>.</li></ul></div></div><a class="source-link" target="_blank" href="https://github.com/fredrikekre/Examples.jl/blob/e0d090e4ed7f4310b1007bffbce0f65196d08f37/src/Examples.jl#L250-L266">source</a></section><h2><a class="nav-anchor" id="Script-output-1" href="#Script-output-1"><strong>4.3.</strong> Script output</a></h2><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Examples.script" href="#Examples.script"><code>Examples.script</code></a><span class="docstring-category">Function</span>.</div><div><div><pre><code class="language-none">Examples.script(inputfile, outputdir; kwargs...)</code></pre><p>Generate a plain script file from <code>inputfile</code> and write the result to <code>outputdir</code>.</p><p>Keyword arguments:</p><ul><li><code>name</code>: name of the output file, excluding <code>.jl</code>. Defaults to the filename of <code>inputfile</code>.</li><li><code>preprocess</code>, <code>postprocess</code>: custom pre- and post-processing functions, see the <a href="customprocessing.html#Custom-pre-and-post-processing-1">Custom pre- and post-processing</a> section of the manual. Defaults to <code>identity</code>.</li></ul></div></div><a class="source-link" target="_blank" href="https://github.com/fredrikekre/Examples.jl/blob/e0d090e4ed7f4310b1007bffbce0f65196d08f37/src/Examples.jl#L93-L104">source</a></section><footer><hr/><a class="previous" href="pipeline.html"><span class="direction">Previous</span><span class="title"><strong>3.</strong> Processing pipeline</span></a><a class="next" href="customprocessing.html"><span class="direction">Next</span><span class="title"><strong>5.</strong> Custom pre- and post-processing</span></a></footer></article></body></html>

29
latest/pipeline.html

@ -0,0 +1,29 @@
<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"/><meta name="viewport" content="width=device-width, initial-scale=1.0"/><title>3. Processing pipeline · Examples.jl</title><link href="https://cdnjs.cloudflare.com/ajax/libs/normalize/4.2.0/normalize.min.css" rel="stylesheet" type="text/css"/><link href="https://fonts.googleapis.com/css?family=Lato|Roboto+Mono" rel="stylesheet" type="text/css"/><link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.6.3/css/font-awesome.min.css" rel="stylesheet" type="text/css"/><link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/default.min.css" rel="stylesheet" type="text/css"/><script>documenterBaseURL="."</script><script src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.2.0/require.min.js" data-main="assets/documenter.js"></script><script src="siteinfo.js"></script><script src="../versions.js"></script><link href="assets/documenter.css" rel="stylesheet" type="text/css"/></head><body><nav class="toc"><h1>Examples.jl</h1><select id="version-selector" onChange="window.location.href=this.value" style="visibility: hidden"></select><form class="search" id="search-form" action="search.html"><input id="search-query" name="q" type="text" placeholder="Search docs"/></form><ul><li><a class="toctext" href="index.html"><strong>1.</strong> Introduction</a></li><li><a class="toctext" href="fileformat.html"><strong>2.</strong> File Format</a></li><li class="current"><a class="toctext" href="pipeline.html"><strong>3.</strong> Processing pipeline</a><ul class="internal"><li><a class="toctext" href="#Pre-processing-1"><strong>3.1.</strong> Pre-processing</a></li><li><a class="toctext" href="#Parsing-1"><strong>3.2.</strong> Parsing</a></li><li><a class="toctext" href="#Document-generation-1"><strong>3.3.</strong> Document generation</a></li><li><a class="toctext" href="#Post-processing-1"><strong>3.4.</strong> Post-processing</a></li><li><a class="toctext" href="#Writing-to-file-1"><strong>3.5.</strong> Writing to file</a></li></ul></li><li><a class="toctext" href="outputformats.html"><strong>4.</strong> Output formats</a></li><li><a class="toctext" href="customprocessing.html"><strong>5.</strong> Custom pre- and post-processing</a></li><li><a class="toctext" href="documenter.html"><strong>6.</strong> Interaction with Documenter.jl</a></li><li><a class="toctext" href="generated/example.html"><strong>7.</strong> Example</a></li></ul></nav><article id="docs"><header><nav><ul><li><a href="pipeline.html"><strong>3.</strong> Processing pipeline</a></li></ul><a class="edit-page" href="https://github.com/fredrikekre/Examples.jl/blob/master/docs/src/pipeline.md"><span class="fa"></span> Edit on GitHub</a></nav><hr/><div id="topbar"><span>3. Processing pipeline</span><a class="fa fa-bars" href="#"></a></div></header><h1><a class="nav-anchor" id="**3.**-Processing-pipeline-1" href="#**3.**-Processing-pipeline-1"><strong>3.</strong> Processing pipeline</a></h1><p>The generation of output follows the same pipeline for all output formats:</p><ol><li><a href="pipeline.html#Pre-processing-1">Pre-processing</a></li><li><a href="pipeline.html#Parsing-1">Parsing</a></li><li><a href="pipeline.html#Document-generation-1">Document generation</a></li><li><a href="pipeline.html#Post-processing-1">Post-processing</a></li><li><a href="pipeline.html#Writing-to-file-1">Writing to file</a></li></ol><h2><a class="nav-anchor" id="Pre-processing-1" href="#Pre-processing-1"><strong>3.1.</strong> Pre-processing</a></h2><p>The first step is pre-processing of the input file. The file is read to a <code>String</code> and CRLF style line endings (<code>&quot;\r\n&quot;</code>) are replaced with LF line endings (<code>&quot;\n&quot;</code>) to simplify internal processing. The next step is to apply the user specified pre-processing function. See <a href="customprocessing.html#Custom-pre-and-post-processing-1">Custom pre- and post-processing</a>.</p><p>Next the line filtering is performed, see <a href="fileformat.html#Filtering-lines-1">Filtering lines</a>, meaning that lines starting with <code>#md</code>, <code>#nb</code> or <code>#jl</code> are handled (either just the token itself is removed, or the full line, depending on the output target).</p><h2><a class="nav-anchor" id="Parsing-1" href="#Parsing-1"><strong>3.2.</strong> Parsing</a></h2><p>After the preprocessing the file is parsed. The first step is to categorize each line and mark them as either markdown or code according to the rules described in the <a href="fileformat.html#Syntax-1">Syntax</a> section. Lets consider the example from the previous section with each line categorized:</p><pre><code class="language-none">#&#39; # Rational numbers &lt;- markdown
#&#39; &lt;- markdown
#&#39; In julia rational numbers can be constructed with the `//` operator. &lt;- markdown
#&#39; Lets define two rational numbers, `x` and `y`: &lt;- markdown
&lt;- code
x = 1 // 3 &lt;- code
y = 2 // 5 &lt;- code
&lt;- code
#&#39; When adding `x` and `y` together we obtain a new rational number: &lt;- markdown
&lt;- code
z = x + y &lt;- code</code></pre><p>In the next step the lines are grouped into &quot;chunks&quot; of markdown and code. This is done by simply collecting adjacent lines of the same &quot;type&quot; into chunks:</p><pre><code class="language-none">#&#39; # Rational numbers ┐
#&#39;
#&#39; In julia rational numbers can be constructed with the `//` operator. │ markdown
#&#39; Lets define two rational numbers, `x` and `y`: ┘
x = 1 // 3 │
y = 2 // 5 │ code
#&#39; When adding `x` and `y` together we obtain a new rational number: ] markdown
z = x + y ┘ code</code></pre><p>In the last parsing step all empty leading and trailing lines for each chunk are removed, but empty lines <em>within the same</em> block are kept. The leading <code>#&#39;</code> tokens are also removed from the markdown chunks. Finally we would end up with the following 4 chunks:</p><p>Chunks #1:</p><pre><code class="language-markdown"># Rational numbers
In julia rational numbers can be constructed with the `//` operator.
Lets define two rational numbers, `x` and `y`:</code></pre><p>Chunk #2:</p><pre><code class="language-julia">x = 1 // 3
y = 2 // 5</code></pre><p>Chunk #3:</p><pre><code class="language-markdown">When adding `x` and `y` together we obtain a new rational number:</code></pre><p>Chunk #4:</p><pre><code class="language-julia">z = x + y</code></pre><p>It is then up to the <a href="pipeline.html#Document-generation-1">Document generation</a> step to decide how these chunks should be treated.</p><h3><a class="nav-anchor" id="Custom-control-over-chunk-splits-1" href="#Custom-control-over-chunk-splits-1">Custom control over chunk splits</a></h3><p>Sometimes it is convenient to be able to manually control how the chunks are split. For example, if you want to split a block of code into two, such that they end up in two different <code>@example</code> blocks or notebook cells. The <code>#-</code> token can be used for this purpose. All lines starting with <code>#-</code> are used as &quot;chunk-splitters&quot;:</p><pre><code class="language-julia">x = 1 // 3
y = 2 // 5
#-
z = x + y</code></pre><p>The example above would result in two consecutive code-chunks.</p><div class="admonition tip"><div class="admonition-title">Tip</div><div class="admonition-text"><p>The rest of the line, after <code>#-</code>, is discarded, so it is possible to use e.g. <code>#-------------</code> as a chunk splitter, which may make the source code more readable.</p></div></div><h2><a class="nav-anchor" id="Document-generation-1" href="#Document-generation-1"><strong>3.3.</strong> Document generation</a></h2><p>After the parsing it is time to generate the output. What is done in this step is very different depending on the output target, and it is describe in more detail in the Output format sections: <a href="outputformats.html#Markdown-output-1">Markdown output</a>, <a href="outputformats.html#Notebook-output-1">Notebook output</a> and <a href="outputformats.html#Script-output-1">Script output</a>. In short, the following is happening:</p><ul><li>Markdown output: markdown chunks are printed as-is, code chunks are put inside a code fence (defaults to <code>@example</code>-blocks),</li><li>Notebook output: markdown chunks are printed in markdown cells, code chunks are put in code cells,</li><li>Script output: markdown chunks are discarded, code chunks are printed as-is.</li></ul><h2><a class="nav-anchor" id="Post-processing-1" href="#Post-processing-1"><strong>3.4.</strong> Post-processing</a></h2><p>When the document is generated the user, again, has the option to hook-into the generation with a custom post-processing function. The reason is that one might want to change things that are only visible in the rendered document. See <a href="customprocessing.html#Custom-pre-and-post-processing-1">Custom pre- and post-processing</a>.</p><h2><a class="nav-anchor" id="Writing-to-file-1" href="#Writing-to-file-1"><strong>3.5.</strong> Writing to file</a></h2><p>The last step of the generation is writing to file. The result is written to <code>$(outputdir)/$(name)(.md|.ipynb|.jl)</code> where <code>outputdir</code> is the output directory supplied by the user (for example <code>docs/generated</code>), and <code>name</code> is a user supplied filename. It is recommended to add the output directory to <code>.gitignore</code> since the idea is that the generated documents will be generated as part of the build process rather than beeing files in the repo.</p><footer><hr/><a class="previous" href="fileformat.html"><span class="direction">Previous</span><span class="title"><strong>2.</strong> File Format</span></a><a class="next" href="outputformats.html"><span class="direction">Next</span><span class="title"><strong>4.</strong> Output formats</span></a></footer></article></body></html>

2
latest/search.html

@ -0,0 +1,2 @@
<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"/><meta name="viewport" content="width=device-width, initial-scale=1.0"/><title>Search · Examples.jl</title><link href="https://cdnjs.cloudflare.com/ajax/libs/normalize/4.2.0/normalize.min.css" rel="stylesheet" type="text/css"/><link href="https://fonts.googleapis.com/css?family=Lato|Roboto+Mono" rel="stylesheet" type="text/css"/><link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.6.3/css/font-awesome.min.css" rel="stylesheet" type="text/css"/><link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/default.min.css" rel="stylesheet" type="text/css"/><script>documenterBaseURL="."</script><script src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.2.0/require.min.js" data-main="assets/documenter.js"></script><script src="siteinfo.js"></script><script src="../versions.js"></script><link href="assets/documenter.css" rel="stylesheet" type="text/css"/></head><body><nav class="toc"><h1>Examples.jl</h1><select id="version-selector" onChange="window.location.href=this.value" style="visibility: hidden"></select><form class="search" id="search-form" action="search.html"><input id="search-query" name="q" type="text" placeholder="Search docs"/></form><ul><li><a class="toctext" href="index.html"><strong>1.</strong> Introduction</a></li><li><a class="toctext" href="fileformat.html"><strong>2.</strong> File Format</a></li><li><a class="toctext" href="pipeline.html"><strong>3.</strong> Processing pipeline</a></li><li><a class="toctext" href="outputformats.html"><strong>4.</strong> Output formats</a></li><li><a class="toctext" href="customprocessing.html"><strong>5.</strong> Custom pre- and post-processing</a></li><li><a class="toctext" href="documenter.html"><strong>6.</strong> Interaction with Documenter.jl</a></li><li><a class="toctext" href="generated/example.html"><strong>7.</strong> Example</a></li></ul></nav><article><header><nav><ul><li>Search</li></ul></nav><hr/><div id="topbar"><span>Search</span><a class="fa fa-bars" href="#"></a></div></header><h1>Search</h1><p id="search-info">Number of results: <span id="search-results-number">loading...</span></p><ul id="search-results"></ul></article></body><script src="search_index.js"></script><script src="assets/search.js"></script></html>

259
latest/search_index.js

@ -0,0 +1,259 @@
var documenterSearchIndex = {"docs": [
{
"location": "index.html#",
"page": "1. Introduction",
"title": "1. Introduction",
"category": "page",
"text": ""
},
{
"location": "index.html#**1.**-Introduction-1",
"page": "1. Introduction",
"title": "1. Introduction",
"category": "section",
"text": "Welcome to the documentation for Examples.jl. A simplistic package to help you organize examples for you package documentation."
},
{
"location": "index.html#What?-1",
"page": "1. Introduction",
"title": "What?",
"category": "section",
"text": "Examples.jl is a package that, based on a single source file, generates markdown, for e.g. Documenter.jl, Jupyter notebooks and uncommented scripts for documentation of your package.The main design goal is simplicity. It should be simple to use, and the syntax should be simple. In short all you have to do is to write a commented julia script!The package consists mainly of three functions, which all takes the same script file as input, but generates different output:Examples.markdown: generates a markdown file\nExamples.notebook: generates an (optionally executed) notebook\nExamples.script: generates a plain script file, removing everything that is not code"
},
{
"location": "index.html#Why?-1",
"page": "1. Introduction",
"title": "Why?",
"category": "section",
"text": "Examples are (probably) the best way to showcase your awesome package, and examples are often the best way for a new user to learn how to use it. It is therefore important that the documentation of your package contains examples for users to read and study. However, people are different, and we all prefer different ways of trying out a new package. Some people wants to RTFM, others want to explore the package interactively in, for example, a notebook, and some people wants to study the source code. The aim of Examples.jl is to make it easy to give the user all of these options, while still keeping maintenance to a minimum.It is quite common that packages have \"example notebooks\" to showcase the package. Notebooks are great for this, but they are not so great with version control, like git. The reason is that a notebook is a very \"rich\" format since it contains output and other metadata. Changes to the notebook thus result in large diffs, which makes it harder to review the actual changes.It is also common that packages include examples in the documentation, for example by using Documenter.jl @example-blocks. This is also great, but it is not quite as interactive as a notebook, for the users who prefer that.Examples.jl tries to solve the problems above by creating the output as a part of the doc build. Examples.jl generates the output from a single source file which makes it easier to maintain, test, and keep the manual and your example notebooks in sync."
},
{
"location": "index.html#How?-1",
"page": "1. Introduction",
"title": "How?",
"category": "section",
"text": "TBD"
},
{
"location": "fileformat.html#",
"page": "2. File Format",
"title": "2. File Format",
"category": "page",
"text": ""
},
{
"location": "fileformat.html#**2.**-File-Format-1",
"page": "2. File Format",
"title": "2. File Format",
"category": "section",
"text": "The source file format for Examples.jl is a regular, commented, julia (.jl) scripts. The idea is that the scripts also serve as documentation on their own and it is also simple to include them in the test-suite, with e.g. include, to make sure the examples stay up do date with other changes in your package."
},
{
"location": "fileformat.html#Syntax-1",
"page": "2. File Format",
"title": "2.1. Syntax",
"category": "section",
"text": "The basic syntax is simple:lines starting with #\' is treated as markdown,\nall other lines are treated as julia code.The reason for using #\' instead of # is that we want to be able to use # as comments, just as in a regular script. Lets look at a simple example:#\' # Rational numbers\n#\'\n#\' In julia rational numbers can be constructed with the `//` operator.\n#\' Lets define two rational numbers, `x` and `y`:\n\nx = 1//3\ny = 2//5\n\n#\' When adding `x` and `y` together we obtain a new rational number:\n\nz = x + yIn the lines #\' we can use regular markdown syntax, for example the # used for the heading and the backticks for formatting code. The other lines are regular julia code. We note a couple of things:The script is valid julia, which means that we can include it and the example will run\nThe script is \"self-explanatory\", i.e. the markdown lines works as comments and thus serve as good documentation on its own.For simple use this is all you need to know, the script above is valid. Let\'s take a look at what the above snippet would generate, with default settings:Examples.markdown: leading #\' are removed, and code lines are wrapped in @example-blocks:\n# Rational numbers\n\nIn julia rational numbers can be constructed with the `//` operator.\nLets define two rational numbers, `x` and `y`:\n\n```@example filename\nx = 1//3\ny = 2//5\n```\n\nWhen adding `x` and `y` together we obtain a new rational number:\n\n```@example filename\nz = x + y\n```\nExamples.notebook: leading #\' are removed, markdown lines are placed in \"markdown\" cells, and code lines in \"code\" cells:\n │ # Rational numbers\n │\n │ In julia rational numbers can be constructed with the `//` operator.\n │ Lets define two rational numbers, `x` and `y`:\n\nIn [1]: │ x = 1//3\n │ y = 2//5\n\nOut [1]: │ 2//5\n\n │ When adding `x` and `y` together we obtain a new rational number:\n\nIn [2]: │ z = x + y\n\nOut [2]: │ 11//15\nExamples.script: all lines starting with #\' are removed:\nx = 1//3\ny = 2//5\n\nz = x + y"
},
{
"location": "fileformat.html#Filtering-lines-1",
"page": "2. File Format",
"title": "2.2. Filtering Lines",
"category": "section",
"text": "It is possible to filter out lines depending on the output format. For this purpose, there are three different \"tokens\" that can be placed on the start of the line:#md: markdown output only,\n#nb: notebook output only,\n#jl: script output only.Lines starting with one of these tokens are filtered out in the preprocessing step.Suppose, for example, that we want to include a docstring within a @docs block using Documenter. Obviously we don\'t want to include this in the notebook, since @docs is Documenter syntax that the notebook will not understand. This is a case where we can prepend #md to those lines:#md #\' ```@docs\n#md #\' Examples.markdown\n#md #\' Examples.notebook\n#md #\' Examples.markdown\n#md #\' ```The lines in the example above would be filtered out in the preprocessing step, unless we are generating a markdown file. When generating a markdown file we would simple remove the leading #md from the lines. Beware that the space after the tag is also removed."
},
{
"location": "pipeline.html#",
"page": "3. Processing pipeline",
"title": "3. Processing pipeline",
"category": "page",
"text": ""
},
{
"location": "pipeline.html#**3.**-Processing-pipeline-1",
"page": "3. Processing pipeline",
"title": "3. Processing pipeline",
"category": "section",
"text": "The generation of output follows the same pipeline for all output formats:Pre-processing\nParsing\nDocument generation\nPost-processing\nWriting to file"
},
{
"location": "pipeline.html#Pre-processing-1",
"page": "3. Processing pipeline",
"title": "3.1. Pre-processing",
"category": "section",
"text": "The first step is pre-processing of the input file. The file is read to a String and CRLF style line endings (\"\\r\\n\") are replaced with LF line endings (\"\\n\") to simplify internal processing. The next step is to apply the user specified pre-processing function. See Custom pre- and post-processing.Next the line filtering is performed, see Filtering lines, meaning that lines starting with #md, #nb or #jl are handled (either just the token itself is removed, or the full line, depending on the output target)."
},
{
"location": "pipeline.html#Parsing-1",
"page": "3. Processing pipeline",
"title": "3.2. Parsing",
"category": "section",
"text": "After the preprocessing the file is parsed. The first step is to categorize each line and mark them as either markdown or code according to the rules described in the Syntax section. Lets consider the example from the previous section with each line categorized:#\' # Rational numbers <- markdown\n#\' <- markdown\n#\' In julia rational numbers can be constructed with the `//` operator. <- markdown\n#\' Lets define two rational numbers, `x` and `y`: <- markdown\n <- code\nx = 1 // 3 <- code\ny = 2 // 5 <- code\n <- code\n#\' When adding `x` and `y` together we obtain a new rational number: <- markdown\n <- code\nz = x + y <- codeIn the next step the lines are grouped into \"chunks\" of markdown and code. This is done by simply collecting adjacent lines of the same \"type\" into chunks:#\' # Rational numbers ┐\n#\' │\n#\' In julia rational numbers can be constructed with the `//` operator. │ markdown\n#\' Lets define two rational numbers, `x` and `y`: ┘\n ┐\nx = 1 // 3 │\ny = 2 // 5 │ code\n ┘\n#\' When adding `x` and `y` together we obtain a new rational number: ] markdown\n ┐\nz = x + y ┘ codeIn the last parsing step all empty leading and trailing lines for each chunk are removed, but empty lines within the same block are kept. The leading #\' tokens are also removed from the markdown chunks. Finally we would end up with the following 4 chunks:Chunks #1:# Rational numbers\n\nIn julia rational numbers can be constructed with the `//` operator.\nLets define two rational numbers, `x` and `y`:Chunk #2:x = 1 // 3\ny = 2 // 5Chunk #3:When adding `x` and `y` together we obtain a new rational number:Chunk #4:z = x + yIt is then up to the Document generation step to decide how these chunks should be treated."
},
{
"location": "pipeline.html#Custom-control-over-chunk-splits-1",
"page": "3. Processing pipeline",
"title": "Custom control over chunk splits",
"category": "section",
"text": "Sometimes it is convenient to be able to manually control how the chunks are split. For example, if you want to split a block of code into two, such that they end up in two different @example blocks or notebook cells. The #- token can be used for this purpose. All lines starting with #- are used as \"chunk-splitters\":x = 1 // 3\ny = 2 // 5\n#-\nz = x + yThe example above would result in two consecutive code-chunks.tip: Tip\nThe rest of the line, after #-, is discarded, so it is possible to use e.g. #------------- as a chunk splitter, which may make the source code more readable."
},
{
"location": "pipeline.html#Document-generation-1",
"page": "3. Processing pipeline",
"title": "3.3. Document generation",
"category": "section",
"text": "After the parsing it is time to generate the output. What is done in this step is very different depending on the output target, and it is describe in more detail in the Output format sections: Markdown output, Notebook output and Script output. In short, the following is happening:Markdown output: markdown chunks are printed as-is, code chunks are put inside a code fence (defaults to @example-blocks),\nNotebook output: markdown chunks are printed in markdown cells, code chunks are put in code cells,\nScript output: markdown chunks are discarded, code chunks are printed as-is."
},
{
"location": "pipeline.html#Post-processing-1",
"page": "3. Processing pipeline",
"title": "3.4. Post-processing",
"category": "section",
"text": "When the document is generated the user, again, has the option to hook-into the generation with a custom post-processing function. The reason is that one might want to change things that are only visible in the rendered document. See Custom pre- and post-processing."
},
{
"location": "pipeline.html#Writing-to-file-1",
"page": "3. Processing pipeline",
"title": "3.5. Writing to file",
"category": "section",
"text": "The last step of the generation is writing to file. The result is written to $(outputdir)/$(name)(.md|.ipynb|.jl) where outputdir is the output directory supplied by the user (for example docs/generated), and name is a user supplied filename. It is recommended to add the output directory to .gitignore since the idea is that the generated documents will be generated as part of the build process rather than beeing files in the repo."
},
{
"location": "outputformats.html#",
"page": "4. Output formats",
"title": "4. Output formats",
"category": "page",
"text": ""
},
{
"location": "outputformats.html#Output-formats-1",
"page": "4. Output formats",
"title": "4. Output formats",
"category": "section",
"text": ""
},
{
"location": "outputformats.html#Examples.markdown",
"page": "4. Output formats",
"title": "Examples.markdown",
"category": "function",
"text": "Examples.markdown(inputfile, outputdir; kwargs...)\n\nGenerate a markdown file from inputfile and write the result to the directoryoutputdir.\n\nKeyword arguments:\n\nname: name of the output file, excluding .md. name is also used to name all the @example blocks. Defaults to the filename of inputfile.\npreprocess, postprocess: custom pre- and post-processing functions, see the Custom pre- and post-processing section of the manual. Defaults to identity.\ncodefence: A Pair of opening and closing code fence. Defaults to\n\"```@example $(name)\" => \"```\"\ndocumenter: boolean that says if the output is intended to use with Documenter.jl. Defaults to false. See the the manual section on Interaction with Documenter.\n\n\n\n\n\n"
},
{
"location": "outputformats.html#Markdown-output-1",
"page": "4. Output formats",
"title": "4.1. Markdown output",
"category": "section",
"text": "#\' # Markdown ┐\n#\' │\n#\' This line is treated as markdown, since it starts with #\' │\n#\' The leading #\' (including the space) is removed ┘\n\n#\' Here is an example with some code ]\n\nx = sin.(cos.([1, 2, 3])) ┐\ny = x.^2 - x ┘By default, CodeChunks written to Documenter @example blocks. For example, the code above would result in the following markdown:# Markdown\n\nThis line is treated as markdown, since it starts with #\'\nThe leading #\' (including the space) is removed\n\nHere is an example with some code\n\n```@example\nx = sin.(cos.([1, 2, 3]))\ny = x.^2 - x\n```Examples.markdown"
},
{
"location": "outputformats.html#Examples.notebook",
"page": "4. Output formats",
"title": "Examples.notebook",
"category": "function",
"text": "Examples.notebook(inputfile, outputdir; kwargs...)\n\nGenerate a notebook from inputfile and write the result to outputdir.\n\nKeyword arguments:\n\nname: name of the output file, excluding .ipynb. Defaults to the filename of inputfile.\npreprocess, postprocess: custom pre- and post-processing functions, see the Custom pre- and post-processing section of the manual. Defaults to identity.\nexecute: a boolean deciding if the generated notebook should also be executed or not. Defaults to false.\ndocumenter: boolean that says if the source contains Documenter.jl specific things to filter out during notebook generation. Defaults to false. See the the manual section on Interaction with Documenter.\n\n\n\n\n\n"
},
{
"location": "outputformats.html#Notebook-output-1",
"page": "4. Output formats",
"title": "4.2. Notebook output",
"category": "section",
"text": "Examples.notebook"
},
{
"location": "outputformats.html#Examples.script",
"page": "4. Output formats",
"title": "Examples.script",
"category": "function",
"text": "Examples.script(inputfile, outputdir; kwargs...)\n\nGenerate a plain script file from inputfile and write the result to outputdir.\n\nKeyword arguments:\n\nname: name of the output file, excluding .jl. Defaults to the filename of inputfile.\npreprocess, postprocess: custom pre- and post-processing functions, see the Custom pre- and post-processing section of the manual. Defaults to identity.\n\n\n\n\n\n"
},
{
"location": "outputformats.html#Script-output-1",
"page": "4. Output formats",
"title": "4.3. Script output",
"category": "section",
"text": "Examples.script"
},
{
"location": "customprocessing.html#",
"page": "5. Custom pre- and post-processing",
"title": "5. Custom pre- and post-processing",
"category": "page",
"text": ""
},
{
"location": "customprocessing.html#Custom-pre-and-post-processing-1",
"page": "5. Custom pre- and post-processing",
"title": "5. Custom pre- and post-processing",
"category": "section",
"text": "Since all packages are different, and may have different demands on how to create a nice example for the documentation it is important that the package maintainer does not feel limited by the by default provided syntax that this package offers. While you can generally come a long way by utilizing line filtering there might be situations where you need to manually hook into the generation and change things. In Examples.jl this is done by letting the user supply custom pre- and post-processing functions that may do transformation of the content.All of the generators (Examples.markdown, Examples.notebook and Examples.script) accepts preprocess and postprocess keyword arguments. The default \"transformation\" is the identity function. The input to the transformation functions is a String, and the output should be the transformed String.preprocess is sent the raw input that is read from the source file (modulo the default line ending transformation). postprocess is given different things depending on the output: For markdown and script output postprocess is given the content String just before writing it to the output file, but for notebook output postprocess is given the dictionary representing the notebook, since, in general, this is more useful.As an example, lets say we want to splice the date of generation into the output. We could of course update our source file before generating the docs, but we could instead use a preprocess function that splices the date into the source for us. Consider the following source file:#\' # Example\n#\' This example was generated DATEOFTODAY\n\nx = 1 // 3where DATEOFTODAY is a placeholder, to make it easier for our preprocess function to find the location. Now, lets define the preprocess function, for examplefunction update_date(content)\n content = replace(content, \"DATEOFTODAY\" => Date(now()))\n return content\nendwhich would replace every occurrence of \"DATEOFTODAY\" with the current date. We would now simply give this function to the generator, for example:Examples.markdown(\"input.jl\", \"outputdir\"; preprocess = update_date)"
},
{
"location": "documenter.html#",
"page": "6. Interaction with Documenter.jl",
"title": "6. Interaction with Documenter.jl",
"category": "page",
"text": ""
},
{
"location": "documenter.html#Interaction-with-Documenter-1",
"page": "6. Interaction with Documenter.jl",
"title": "6. Interaction with Documenter.jl",
"category": "section",
"text": "TBW"
},
{
"location": "generated/example.html#",
"page": "7. Example",
"title": "7. Example",
"category": "page",
"text": ""
},
{
"location": "generated/example.html#**7.**-Example-1",
"page": "7. Example",
"title": "7. Example",
"category": "section",
"text": "Output generated with Examples.jl based on this source file.This is an example source file for input to Examples.jl.If you are reading this you are seeing the markdown output generated from the source file, here you can see the corresponding notebook output: example.ipynb"
},
{
"location": "generated/example.html#Rational-numbers-in-Julia-1",
"page": "7. Example",
"title": "Rational numbers in Julia",
"category": "section",
"text": "Rational number in julia can be constructed with the // operator:x = 1//3\ny = 2//5Operations with rational number returns a new rational numberx + yx * yEverytime a rational number is constructed, it will be simplified using the gcd function, for example 2//4 simplifies to 1//2:2//4and 2//4 + 2//4 simplifies to 1//1:2//4 + 2//4"
},
]}

1
latest/siteinfo.js

@ -0,0 +1 @@
var DOCUMENTER_CURRENT_VERSION = "latest";

3
versions.js

@ -0,0 +1,3 @@
var DOC_VERSIONS = [
"latest",
];
Loading…
Cancel
Save