--- /dev/null
+
+
+---
+title: Hugo and the General Data Protection Regulation (GDPR)
+linktitle: Hugo and GDPR
+description: About how to configure your Hugo site to meet the new regulations.
+date: 2018-05-25
+layout: single
+keywords: ["GDPR", "Privacy", "Data Protection"]
+menu:
+ docs:
+ parent: "about"
+ weight: 5
+weight: 5
+sections_weight: 5
+draft: false
+aliases: [/privacy/,/gdpr/]
+toc: true
+---
+
+
+ General Data Protection Regulation ([GDPR](https://en.wikipedia.org/wiki/General_Data_Protection_Regulation)) is a regulation in EU law on data protection and privacy for all individuals within the European Union and the European Economic Area. It became enforceable on 25 May 2018.
+
+ **Hugo is a static site generator. By using Hugo you are already standing on very solid ground. Static HTML files on disk are much easier to reason about compared to server and database driven web sites.**
+
+ But even static websites can integrate with external services, so from version `0.41`, Hugo provides a **Privacy Config** that covers the relevant built-in templates.
+
+ Note that:
+
+ * These settings have their defaults setting set to _off_, i.e. how it worked before Hugo `0.41`. You must do your own evaluation of your site and apply the appropriate settings.
++ * These settings work with the [internal templates](/templates/internal/). Some theme may contain custom templates for embedding services like Google Analytics. In that case these options have no effect.
+ * We will continue this work and improve this further in future Hugo versions.
+
+## All Privacy Settings
+
+Below are all privacy settings and their default value. These settings need to be put in your site config (e.g. `config.toml`).
+
+ {{< code-toggle file="config">}}
+[privacy]
+[privacy.disqus]
+disable = false
+[privacy.googleAnalytics]
+disable = false
+respectDoNotTrack = false
+anonymizeIP = false
+useSessionStorage = false
+[privacy.instagram]
+disable = false
+simple = false
+[privacy.twitter]
+disable = false
+enableDNT = false
+simple = false
+[privacy.vimeo]
+disable = false
+simple = false
+[privacy.youtube]
+disable = false
+privacyEnhanced = false
+{{< /code-toggle >}}
+
+
+## Disable All Services
+
+An example Privacy Config that disables all the relevant services in Hugo. With this configuration, the other settings will not matter.
+
+ {{< code-toggle file="config">}}
+[privacy]
+[privacy.disqus]
+disable = true
+[privacy.googleAnalytics]
+disable = true
+[privacy.instagram]
+disable = true
+[privacy.twitter]
+disable = true
+[privacy.vimeo]
+disable = true
+[privacy.youtube]
+disable = true
+{{< /code-toggle >}}
+
+## The Privacy Settings Explained
+
+### GoogleAnalytics
+
+anonymizeIP
+: Enabling this will make it so the users' IP addresses are anonymized within Google Analytics.
+
+respectDoNotTrack
+: Enabling this will make the GA templates respect the "Do Not Track" HTTP header.
+
+useSessionStorage
+: Enabling this will disable the use of Cookies and use Session Storage to Store the GA Client ID.
+
+### Instagram
+
+simple
+: If simple mode is enabled, a static and no-JS version of the Instagram image card will be built. Note that this only supports image cards and the image itself will be fetched from Instagram's servers.
+
+**Note:** If you use the _simple mode_ for Instagram and a site styled with Bootstrap 4, you may want to disable the inlines styles provided by Hugo:
+
+ {{< code-toggle file="config">}}
+[services]
+[services.instagram]
+disableInlineCSS = true
+{{< /code-toggle >}}
+
+### Twitter
+
+enableDNT
+: Enabling this for the twitter/tweet shortcode, the tweet and its embedded page on your site are not used for purposes that include personalized suggestions and personalized ads.
+
+simple
+: If simple mode is enabled, a static and no-JS version of a tweet will be built.
+
+
+**Note:** If you use the _simple mode_ for Twitter, you may want to disable the inlines styles provided by Hugo:
+
+ {{< code-toggle file="config">}}
+[services]
+[services.twitter]
+disableInlineCSS = true
+{{< /code-toggle >}}
+
+### YouTube
+
+privacyEnhanced
+: When you turn on privacy-enhanced mode, YouTube won’t store information about visitors on your website unless the user plays the embedded video.
+
+### Vimeo
+
+simple
+: If simple mode is enabled, the video thumbnail is fetched from Vimeo's servers and it is overlayed with a play button. If the user clicks to play the video, it will open in a new tab directly on Vimeo's website.
+
--- /dev/null
- The last two list items is only applicable if you use a theme and it uses the `my-theme` theme name as an example.
+---
+title: Archetypes
+linktitle: Archetypes
+description: Archetypes are templates used when creating new content.
+date: 2017-02-01
+publishdate: 2017-02-01
+keywords: [archetypes,generators,metadata,front matter]
+categories: ["content management"]
+menu:
+ docs:
+ parent: "content-management"
+ weight: 70
+ quicklinks:
+weight: 70 #rem
+draft: false
+aliases: [/content/archetypes/]
+toc: true
+---
+
+## What are Archetypes?
+
+**Archetypes** are content template files in the [archetypes directory][] of your project that contain preconfigured [front matter][] and possibly also a content disposition for your website's [content types][]. These will be used when you run `hugo new`.
+
+
+The `hugo new` uses the `content-section` to find the most suitable archetype template in your project. If your project does not contain any archetype files, it will also look in the theme.
+
+{{< code file="archetype-example.sh" >}}
+hugo new posts/my-first-post.md
+{{< /code >}}
+
+The above will create a new content file in `content/posts/my-first-post.md` using the first archetype file found of these:
+
+1. `archetypes/posts.md`
+2. `archetypes/default.md`
+3. `themes/my-theme/archetypes/posts.md`
+4. `themes/my-theme/archetypes/default.md`
+
++The last two list items are only applicable if you use a theme and it uses the `my-theme` theme name as an example.
+
+## Create a New Archetype Template
+
+A fictional example for the section `newsletter` and the archetype file `archetypes/newsletter.md`. Create a new file in `archetypes/newsletter.md` and open it in a text editor.
+
+{{< code file="archetypes/newsletter.md" >}}
+---
+title: "{{ replace .Name "-" " " | title }}"
+date: {{ .Date }}
+draft: true
+---
+
+**Insert Lead paragraph here.**
+
+## New Cool Posts
+
+{{ range first 10 ( where .Site.RegularPages "Type" "cool" ) }}
+* {{ .Title }}
+{{ end }}
+{{< /code >}}
+
+When you create a new newsletter with:
+
+```bash
+hugo new newsletter/the-latest-cool.stuff.md
+```
+
+It will create a new newsletter type of content file based on the archetype template.
+
+**Note:** the site will only be built if the `.Site` is in use in the archetype file, and this can be time consuming for big sites.
+
+The above _newsletter type archetype_ illustrates the possibilities: The full Hugo `.Site` and all of Hugo's template funcs can be used in the archetype file.
+
+
+[archetypes directory]: /getting-started/directory-structure/
+[content types]: /content-management/types/
+[front matter]: /content-management/front-matter/
--- /dev/null
-
+---
+title: Comments
+linktitle: Comments
+description: Hugo ships with an internal Disqus template, but this isn't the only commenting system that will work with your new Hugo website.
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-03-09
+keywords: [sections,content,organization]
+categories: [project organization, fundamentals]
+menu:
+ docs:
+ parent: "content-management"
+ weight: 140
+weight: 140 #rem
+draft: false
+aliases: [/extras/comments/]
+toc: true
+---
+
+Hugo ships with support for [Disqus](https://disqus.com/), a third-party service that provides comment and community capabilities to websites via JavaScript.
+
+Your theme may already support Disqus, but if not, it is easy to add to your templates via [Hugo's built-in Disqus partial][disquspartial].
+
+## Add Disqus
+
+Hugo comes with all the code you need to load Disqus into your templates. Before adding Disqus to your site, you'll need to [set up an account][disqussetup].
+
+### Configure Disqus
+
+Disqus comments require you set a single value in your [site's configuration file][configuration] like so:
+
+{{< code-toggle copy="false" >}}
+disqusShortname = "yourdiscussshortname"
+{{</ code-toggle >}}
+
+For many websites, this is enough configuration. However, you also have the option to set the following in the [front matter][] of a single content file:
+
+* `disqus_identifier`
+* `disqus_title`
+* `disqus_url`
+
+### Render Hugo's Built-in Disqus Partial Template
+
+Disqus has its own [internal template](https://gohugo.io/templates/internal/#disqus) available, to render it add the following code where you want comments to appear:
+
+```
+{{ template "_internal/disqus.html" . }}
+```
+
+## Comments Alternatives
+
+There are a few alternatives to commenting on static sites for those who do not want to use Disqus:
+
+* [Static Man](https://staticman.net/)
+* [Talkyard](https://www.talkyard.io/blog-comments) (Open source, & serverless hosting)
+* [txtpen](https://txtpen.github.io/hn/)
+* [IntenseDebate](http://intensedebate.com/)
+* [Graph Comment][]
+* [Muut](http://muut.com/)
+* [isso](http://posativ.org/isso/) (Self-hosted, Python)
+ * [Tutorial on Implementing Isso with Hugo][issotutorial]
++* [Utterances](https://utteranc.es/) (Open source, Github comments widget built on Github issues)
+
+<!-- I don't think this is worth including in the documentation since it seems that Steve is no longer supporting or developing this project. rdwatters - 2017-02-29.-->
+<!-- * [Kaiju](https://github.com/spf13/kaiju) -->
+
+<!-- ## Kaiju
+
+[Kaiju](https://github.com/spf13/kaiju) is an open-source project started by [spf13](http://spf13.com/) (Hugo’s author) to bring easy and fast real time discussions to the web.
+
+Written using Go, Socket.io, and [MongoDB][], Kaiju is very fast and easy to deploy.
+
+It is in early development but shows promise. If you have interest, please help by contributing via pull request, [opening an issue in the Kaiju GitHub repository][kaijuissue], or [Tweeting about it][tweet]. Every bit helps. -->
+
+[configuration]: /getting-started/configuration/
+[disquspartial]: /templates/partials/#disqus
+[disqussetup]: https://disqus.com/profile/signup/
+[forum]: https://discourse.gohugo.io
+[front matter]: /content-management/front-matter/
+[Graph Comment]: https://graphcomment.com/
+[kaijuissue]: https://github.com/spf13/kaiju/issues/new
+[issotutorial]: https://stiobhart.net/2017-02-24-isso-comments/
+[partials]: /templates/partials/
+[MongoDB]: https://www.mongodb.com/
+[tweet]: https://twitter.com/spf13
--- /dev/null
- [Miek Gieben's website]: https://miek.nl/2016/March/05/mmark-syntax-document/
+---
+title: Supported Content Formats
+linktitle: Supported Content Formats
+description: Markdown and Emacs Org-Mode have native support, and additional formats (e.g. Asciidoc) come via external helpers.
+date: 2017-01-10
+publishdate: 2017-01-10
+lastmod: 2017-04-06
+categories: [content management]
+keywords: [markdown,asciidoc,mmark,pandoc,content format]
+menu:
+ docs:
+ parent: "content-management"
+ weight: 20
+weight: 20 #rem
+draft: false
+aliases: [/content/markdown-extras/,/content/supported-formats/,/doc/supported-formats/,/tutorials/mathjax/]
+toc: true
+---
+
+**Markdown is the main content format** and comes in two flavours: The excellent [Blackfriday project][blackfriday] (name your files `*.md` or set `markup = "markdown"` in front matter) or its fork [Mmark][mmark] (name your files `*.mmark` or set `markup = "mmark"` in front matter), both very fast markdown engines written in Go.
+
+For Emacs users, [goorgeous](https://github.com/chaseadamsio/goorgeous) provides built-in native support for Org-mode (name your files `*.org` or set `markup = "org"` in front matter)
+
+{{% note "Deeply Nested Lists" %}}
+Before you begin writing your content in markdown, Blackfriday has a known issue [(#329)](https://github.com/russross/blackfriday/issues/329) with handling deeply nested lists. Luckily, there is an easy workaround. Use 4-spaces (i.e., <kbd>tab</kbd>) rather than 2-space indentations.
+{{% /note %}}
+
+## Configure BlackFriday Markdown Rendering
+
+You can configure multiple aspects of Blackfriday as show in the following list. See the docs on [Configuration][config] for the full list of explicit directions you can give to Hugo when rendering your site.
+
+{{< readfile file="/content/en/readfiles/bfconfig.md" markdown="true" >}}
+
+## Extend Markdown
+
+Hugo provides some convenient methods for extending markdown.
+
+### Task Lists
+
+Hugo supports [GitHub-styled task lists (i.e., TODO lists)][gfmtasks] for the Blackfriday markdown renderer. If you do not want to use this feature, you can disable it in your configuration.
+
+#### Example Task List Input
+
+{{< code file="content/my-to-do-list.md" >}}
+- [ ] a task list item
+- [ ] list syntax required
+- [ ] incomplete
+- [x] completed
+{{< /code >}}
+
+#### Example Task List Output
+
+The preceding markdown produces the following HTML in your rendered website:
+
+```
+<ul class="task-list">
+ <li><input type="checkbox" disabled="" class="task-list-item"> a task list item</li>
+ <li><input type="checkbox" disabled="" class="task-list-item"> list syntax required</li>
+ <li><input type="checkbox" disabled="" class="task-list-item"> incomplete</li>
+ <li><input type="checkbox" checked="" disabled="" class="task-list-item"> completed</li>
+</ul>
+```
+
+#### Example Task List Display
+
+The following shows how the example task list will look to the end users of your website. Note that visual styling of lists is up to you. This list has been styled according to [the Hugo Docs stylesheet][hugocss].
+
+- [ ] a task list item
+- [ ] list syntax required
+- [ ] incomplete
+- [x] completed
+
+### Emojis
+
+To add emojis directly to content, set `enableEmoji` to `true` in your [site configuration][config]. To use emojis in templates or shortcodes, see [`emojify` function][].
+
+For a full list of emojis, see the [Emoji cheat sheet][emojis].
+
+### Shortcodes
+
+If you write in Markdown and find yourself frequently embedding your content with raw HTML, Hugo provides built-in shortcodes functionality. This is one of the most powerful features in Hugo and allows you to create your own Markdown extensions very quickly.
+
+See [Shortcodes][sc] for usage, particularly for the built-in shortcodes that ship with Hugo, and [Shortcode Templating][sct] to learn how to build your own.
+
+### Code Blocks
+
+Hugo supports GitHub-flavored markdown's use of triple back ticks, as well as provides a special [`highlight` shortcode][hlsc], and syntax highlights those code blocks natively using *Chroma*. Users also have an option to use *Pygments* instead. See the [Syntax Highlighting][hl] section for details.
+
+## Mmark
+
+Mmark is a [fork of BlackFriday][mmark] and markdown superset that is well suited for writing [IETF documentation][ietf]. You can see examples of the syntax in the [Mmark GitHub repository][mmarkgh] or the full syntax on [Miek Gieben's website][].
+
+### Use Mmark
+
+As Hugo ships with Mmark, using the syntax is as easy as changing the extension of your content files from `.md` to `.mmark`.
+
+In the event that you want to only use Mmark in specific files, you can also define the Mmark syntax in your content's front matter:
+
+```
+---
+title: My Post
+date: 2017-04-01
+markup: mmark
+---
+```
+
+{{% warning %}}
+Thare are some features not available in Mmark; one example being that shortcodes are not translated when used in an included `.mmark` file ([#3131](https://github.com/gohugoio/hugo/issues/3137)), and `EXTENSION_ABBREVIATION` ([#1970](https://github.com/gohugoio/hugo/issues/1970)) and the aforementioned GFM todo lists ([#2270](https://github.com/gohugoio/hugo/issues/2270)) are not fully supported. Contributions are welcome.
+{{% /warning %}}
+
+## MathJax with Hugo
+
+[MathJax](http://www.mathjax.org/) is a JavaScript library that allows the display of mathematical expressions described via a LaTeX-style syntax in the HTML (or Markdown) source of a web page. As it is a pure a JavaScript library, getting it to work within Hugo is fairly straightforward, but does have some oddities that will be discussed here.
+
+This is not an introduction into actually using MathJax to render typeset mathematics on your website. Instead, this page is a collection of tips and hints for one way to get MathJax working on a website built with Hugo.
+
+### Enable MathJax
+
+The first step is to enable MathJax on pages that you would like to have typeset math. There are multiple ways to do this (adventurous readers can consult the [Loading and Configuring](http://docs.mathjax.org/en/latest/configuration.html) section of the MathJax documentation for additional methods of including MathJax), but the easiest way is to use the secure MathJax CDN by include a `<script>` tag for the officially recommended secure CDN ([cdn.js.com](https://cdnjs.com)):
+
+{{< code file="add-mathjax-to-page.html" >}}
+<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
+</script>
+{{< /code >}}
+
+One way to ensure that this code is included in all pages is to put it in one of the templates that live in the `layouts/partials/` directory. For example, I have included this in the bottom of my template `footer.html` because I know that the footer will be included in every page of my website.
+
+### Options and Features
+
+MathJax is a stable open-source library with many features. I encourage the interested reader to view the [MathJax Documentation](http://docs.mathjax.org/en/latest/index.html), specifically the sections on [Basic Usage](http://docs.mathjax.org/en/latest/index.html#basic-usage) and [MathJax Configuration Options](http://docs.mathjax.org/en/latest/index.html#mathjax-configuration-options).
+
+### Issues with Markdown
+
+{{% note %}}
+The following issues with Markdown assume you are using `.md` for content and BlackFriday for parsing. Using [Mmark](#mmark) as your content format will obviate the need for the following workarounds.
+
+When using Mmark with MathJax, use `displayMath: [['$$','$$'], ['\\[','\\]']]`. See the [Mmark `README.md`](https://github.com/miekg/mmark/wiki/Syntax#math-blocks) for more information. In addition to MathJax, Mmark has been shown to work well with [KaTeX](https://github.com/Khan/KaTeX). See this [related blog post from a Hugo user](http://nosubstance.me/post/a-great-toolset-for-static-blogging/).
+{{% /note %}}
+
+After enabling MathJax, any math entered between proper markers (see the [MathJax documentation][mathjaxdocs]) will be processed and typeset in the web page. One issue that comes up, however, with Markdown is that the underscore character (`_`) is interpreted by Markdown as a way to wrap text in `emph` blocks while LaTeX (MathJax) interprets the underscore as a way to create a subscript. This "double speak" of the underscore can result in some unexpected and unwanted behavior.
+
+### Solution
+
+There are multiple ways to remedy this problem. One solution is to simply escape each underscore in your math code by entering `\_` instead of `_`. This can become quite tedious if the equations you are entering are full of subscripts.
+
+Another option is to tell Markdown to treat the MathJax code as verbatim code and not process it. One way to do this is to wrap the math expression inside a `<div>` `</div>` block. Markdown would ignore these sections and they would get passed directly on to MathJax and processed correctly. This works great for display style mathematics, but for inline math expressions the line break induced by the `<div>` is not acceptable. The syntax for instructing Markdown to treat inline text as verbatim is by wrapping it in backticks (`` ` ``). You might have noticed, however, that the text included in between backticks is rendered differently than standard text (on this site these are items highlighted in red). To get around this problem, we could create a new CSS entry that would apply standard styling to all inline verbatim text that includes MathJax code. Below I will show the HTML and CSS source that would accomplish this (note this solution was adapted from [this blog post](http://doswa.com/2011/07/20/mathjax-in-markdown.html)---all credit goes to the original author).
+
+{{< code file="mathjax-markdown-solution.html" >}}
+<script type="text/x-mathjax-config">
+MathJax.Hub.Config({
+ tex2jax: {
+ inlineMath: [['$','$'], ['\\(','\\)']],
+ displayMath: [['$$','$$'], ['\[','\]']],
+ processEscapes: true,
+ processEnvironments: true,
+ skipTags: ['script', 'noscript', 'style', 'textarea', 'pre'],
+ TeX: { equationNumbers: { autoNumber: "AMS" },
+ extensions: ["AMSmath.js", "AMSsymbols.js"] }
+ }
+});
+</script>
+
+<script type="text/x-mathjax-config">
+ MathJax.Hub.Queue(function() {
+ // Fix <code> tags after MathJax finishes running. This is a
+ // hack to overcome a shortcoming of Markdown. Discussion at
+ // https://github.com/mojombo/jekyll/issues/199
+ var all = MathJax.Hub.getAllJax(), i;
+ for(i = 0; i < all.length; i += 1) {
+ all[i].SourceElement().parentNode.className += ' has-jax';
+ }
+});
+</script>
+{{< /code >}}
+
+
+
+As before, this content should be included in the HTML source of each page that will be using MathJax. The next code snippet contains the CSS that is used to have verbatim MathJax blocks render with the same font style as the body of the page.
+
+{{< code file="mathjax-style.css" >}}
+code.has-jax {
+ font: inherit;
+ font-size: 100%;
+ background: inherit;
+ border: inherit;
+ color: #515151;
+}
+{{< /code >}}
+
+In the CSS snippet, notice the line `color: #515151;`. `#515151` is the value assigned to the `color` attribute of the `body` class in my CSS. In order for the equations to fit in with the body of a web page, this value should be the same as the color of the body.
+
+### Usage
+
+With this setup, everything is in place for a natural usage of MathJax on pages generated using Hugo. In order to include inline mathematics, just put LaTeX code in between `` `$ TeX Code $` `` or `` `\( TeX Code \)` ``. To include display style mathematics, just put LaTeX code in between `<div>$$TeX Code$$</div>`. All the math will be properly typeset and displayed within your Hugo generated web page!
+
+## Additional Formats Through External Helpers
+
+Hugo has a new concept called _external helpers_. It means that you can write your content using [Asciidoc][ascii], [reStructuredText][rest], or [pandoc]. If you have files with associated extensions, Hugo will call external commands to generate the content. ([See the Hugo source code for external helpers][helperssource].)
+
+For example, for Asciidoc files, Hugo will try to call the `asciidoctor` or `asciidoc` command. This means that you will have to install the associated tool on your machine to be able to use these formats. ([See the Asciidoctor docs for installation instructions](http://asciidoctor.org/docs/install-toolchain/)).
+
+To use these formats, just use the standard extension and the front matter exactly as you would do with natively supported `.md` files.
+
+Hugo passes reasonable default arguments to these external helpers by default:
+
+- `asciidoc`: `--no-header-footer --safe -`
+- `asciidoctor`: `--no-header-footer --safe --trace -`
+- `rst2html`: `--leave-comments --initial-header-level=2`
+- `pandoc`: `--mathjax`
+
+{{% warning "Performance of External Helpers" %}}
+Because additional formats are external commands generation performance will rely heavily on the performance of the external tool you are using. As this feature is still in its infancy, feedback is welcome.
+{{% /warning %}}
+
+## Learn Markdown
+
+Markdown syntax is simple enough to learn in a single sitting. The following are excellent resources to get you up and running:
+
+* [Daring Fireball: Markdown, John Gruber (Creator of Markdown)][fireball]
+* [Markdown Cheatsheet, Adam Pritchard][mdcheatsheet]
+* [Markdown Tutorial (Interactive), Garen Torikian][mdtutorial]
+* [The Markdown Guide, Matt Cone][mdguide]
+
+[`emojify` function]: /functions/emojify/
+[ascii]: http://asciidoctor.org/
+[bfconfig]: /getting-started/configuration/#configuring-blackfriday-rendering
+[blackfriday]: https://github.com/russross/blackfriday
+[mmark]: https://github.com/miekg/mmark
+[config]: /getting-started/configuration/
+[developer tools]: /tools/
+[emojis]: https://www.webpagefx.com/tools/emoji-cheat-sheet/
+[fireball]: https://daringfireball.net/projects/markdown/
+[gfmtasks]: https://guides.github.com/features/mastering-markdown/#syntax
+[helperssource]: https://github.com/gohugoio/hugo/blob/77c60a3440806067109347d04eb5368b65ea0fe8/helpers/general.go#L65
+[hl]: /content-management/syntax-highlighting/
+[hlsc]: /content-management/shortcodes/#highlight
+[hugocss]: /css/style.css
+[ietf]: https://tools.ietf.org/html/
+[mathjaxdocs]: https://docs.mathjax.org/en/latest/
+[mdcheatsheet]: https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet
+[mdguide]: https://www.markdownguide.org/
+[mdtutorial]: http://www.markdowntutorial.com/
++[Miek Gieben's website]: https://miek.nl/2016/march/05/mmark-syntax-document/
+[mmark]: https://github.com/miekg/mmark
+[mmarkgh]: https://github.com/miekg/mmark/wiki/Syntax
+[org]: http://orgmode.org/
+[pandoc]: http://www.pandoc.org/
+[Pygments]: http://pygments.org/
+[rest]: http://docutils.sourceforge.net/rst.html
+[sc]: /content-management/shortcodes/
+[sct]: /templates/shortcode-templates/
--- /dev/null
- {{< code-toggle file="config.toml" >}}
+---
+title: Menus
+linktitle: Menus
+description: Hugo has a simple yet powerful menu system.
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-03-31
+categories: [content management]
+keywords: [menus]
+draft: false
+menu:
+ docs:
+ parent: "content-management"
+ weight: 120
+weight: 120 #rem
+aliases: [/extras/menus/]
+toc: true
+---
+
+{{% note "Lazy Blogger"%}}
+If all you want is a simple menu for your sections, see the ["Section Menu for Lazy Bloggers" in Menu Templates](/templates/menu-templates/#section-menu-for-lazy-bloggers).
+{{% /note %}}
+
+You can do this:
+
+* Place content in one or many menus
+* Handle nested menus with unlimited depth
+* Create menu entries without being attached to any content
+* Distinguish active element (and active branch)
+
+## What is a Menu in Hugo?
+
+A **menu** is a named array of menu entries accessible by name via the [`.Site.Menus` site variable][sitevars]. For example, you can access your site's `main` menu via `.Site.Menus.main`.
+
+{{% note "Menus on Multilingual Sites" %}}
+If you make use of the [multilingual feature](/content-management/multilingual/), you can define language-independent menus.
+{{% /note %}}
+
+See the [Menu Entry Properties][me-props] for all the variables and functions related to a menu entry.
+
+## Add content to menus
+
+Hugo allows you to add content to a menu via the content's [front matter](/content-management/front-matter/).
+
+### Simple
+
+If all you need to do is add an entry to a menu, the simple form works well.
+
+#### A Single Menu
+
+```
+---
+menu: "main"
+---
+```
+
+#### Multiple Menus
+
+```
+---
+menu: ["main", "footer"]
+---
+```
+
+#### Advanced
+
+
+```
+---
+menu:
+ docs:
+ parent: 'extras'
+ weight: 20
+---
+```
+
+## Add Non-content Entries to a Menu
+
+You can also add entries to menus that aren’t attached to a piece of content. This takes place in your Hugo project's [`config` file][config].
+
+Here’s an example snippet pulled from a configuration file:
+
++{{< code-toggle file="config" >}}
+[[menu.main]]
+ name = "about hugo"
+ pre = "<i class='fa fa-heart'></i>"
+ weight = -110
+ identifier = "about"
+ url = "/about/"
+[[menu.main]]
+ name = "getting started"
+ pre = "<i class='fa fa-road'></i>"
++ post = "<span class='alert'>New!</span>"
+ weight = -100
+ url = "/getting-started/"
+{{< /code-toggle >}}
+
+{{% note %}}
+The URLs must be relative to the context root. If the `baseURL` is `https://example.com/mysite/`, then the URLs in the menu must not include the context root `mysite`. Using an absolute URL will override the baseURL. If the value used for `URL` in the above example is `https://subdomain.example.com/`, the output will be `https://subdomain.example.com`.
+{{% /note %}}
+
+## Nesting
+
+All nesting of content is done via the `parent` field.
+
+The parent of an entry should be the identifier of another entry. The identifier should be unique (within a menu).
+
+The following order is used to determine an Identifier:
+
+`.Name > .LinkTitle > .Title`
+
+This means that `.Title` will be used unless `.LinkTitle` is present, etc. In practice, `.Name` and `.Identifier` are only used to structure relationships and therefore never displayed.
+
+In this example, the top level of the menu is defined in your [site `config` file][config]). All content entries are attached to one of these entries via the `.Parent` field.
+
+## Render Menus
+
+See [Menu Templates](/templates/menu-templates/) for information on how to render your site menus within your templates.
+
+[config]: /getting-started/configuration/
+[multilingual]: /content-management/multilingual/
+[sitevars]: /variables/
+[me-props]: /variables/menus/
--- /dev/null
- {{% note %}}
- We currently do not index **Page content**. We thought we would release something that will make most people happy before we start solving [Sherlock's last case](https://github.com/joearms/sherlock).
- {{% /note %}}
+---
+title: Related Content
+description: List related content in "See Also" sections.
+date: 2017-09-05
+categories: [content management]
+keywords: [content]
+menu:
+ docs:
+ parent: "content-management"
+ weight: 40
+weight: 30
+draft: false
+aliases: [/content/related/,/related/]
+toc: true
+---
+
- To list up to 5 related pages is as simple as including something similar to this partial in your single page template:
++
++Hugo uses a set of factors to identify a page's related content based on Front Matter parameters. This can be tuned to the desired set of indices and parameters or left to Hugo's default [Related Content configuration](#configure-related-content).
+
+## List Related Content
+
- {{% note %}}
- Read [this blog article](https://regisphilibert.com/blog/2018/04/hugo-optmized-relashionships-with-related-content/) for a great explanation of more advanced usage of this feature.
- {{% /note %}}
++
++To list up to 5 related pages (which share the same _date_ or _keyword_ parameters) is as simple as including something similar to this partial in your single page template:
+
+{{< code file="layouts/partials/related.html" >}}
+{{ $related := .Site.RegularPages.Related . | first 5 }}
+{{ with $related }}
+<h3>See Also</h3>
+<ul>
+ {{ range . }}
+ <li><a href="{{ .RelPermalink }}">{{ .Title }}</a></li>
+ {{ end }}
+</ul>
+{{ end }}
+{{< /code >}}
+
++### Methods
+
- The full set of methods available on the page lists can be seen in this Go interface:
++Here is the list of "Related" methods available on a page collection such `.RegularPages`.
+
- ```go
- // A PageGenealogist finds related pages in a page collection. This interface is implemented
- // by Pages and PageGroup, which makes it available as `{{ .RegularPages.Related . }}` etc.
- type PageGenealogist interface {
++#### .Related PAGE
++Returns a collection of pages related the given one.
+
- // Template example:
- // {{ $related := .RegularPages.Related . }}
- Related(doc related.Document) (Pages, error)
++```
++{{ $related := .RegularPages.Related . }}
++```
+
- // Template example:
- // {{ $related := .RegularPages.RelatedIndices . "tags" "date" }}
- RelatedIndices(doc related.Document, indices ...interface{}) (Pages, error)
++#### .RelatedIndices PAGE INDICE1 [INDICE2 ...]
++Returns a collection of pages related to a given one restricted to a list of indices.
+
- // Template example:
- // {{ $related := .RegularPages.RelatedTo ( keyVals "tags" "hugo" "rocks") ( keyVals "date" .Date ) }}
- RelatedTo(args ...types.KeyValues) (Pages, error)
- }
++```
++{{ $related := .RegularPages.RelatedIndices . "tags" "date" }}
++```
++
++#### .RelatedTo KEYVALS [KEYVALS2 ...]
++Returns a collection of pages related together by a set of indices and their match.
+
- Below is a sample `config.toml` section:
-
- ```
- [related]
-
- # Only include matches with rank >= threshold. This is a normalized rank between 0 and 100.
- threshold = 80
-
- # To get stable "See also" sections we, by default, exclude newer related pages.
- includeNewer = false
-
- # Will lower case keywords in both queries and in the indexes.
- toLower = false
-
- [[related.indices]]
- name = "keywords"
- weight = 150
- [[related.indices]]
- name = "author"
- toLower = true
- weight = 30
- [[related.indices]]
- name = "tags"
- weight = 100
- [[related.indices]]
- name = "date"
- weight = 10
- pattern = "2006"
- ```
++In order to build those set and pass them as argument, one must use the `keyVals` function where the first agrument would be the `indice` and the consective ones its potential `matches`.
++
++```
++{{ $related := .RegularPages.RelatedTo ( keyVals "tags" "hugo" "rocks") ( keyVals "date" .Date ) }}
+```
++
++{{% note %}}
++Read [this blog article](https://regisphilibert.com/blog/2018/04/hugo-optmized-relashionships-with-related-content/) for a great explanation of more advanced usage of this feature.
++{{% /note %}}
++
+## Configure Related Content
+Hugo provides a sensible default configuration of Related Content, but you can fine-tune this in your configuration, on the global or language level if needed.
+
++### Default configuration
++
++Without any `related` configuration set on the project, Hugo's Related Content methods will use the following.
++
++```yaml
++related:
++ threshold: 80
++ includeNewer: false
++ toLower: false
++ indices:
++ - name: keywords
++ weight: 100
++ - name: date
++ weight: 10
++```
++
++Custom configuration should be set using the same syntax.
++
+{{% note %}}
+If you add a `related` config section, you need to add a complete configuration. It is not possible to just set, say, `includeNewer` and use the rest from the Hugo defaults.
+{{% /note %}}
+
-
-
-
-
-
-
+### Top Level Config Options
+
+threshold
+: A value between 0-100. Lower value will give more, but maybe not so relevant, matches.
+
+includeNewer
+: Set to true to include **pages newer than the current page** in the related content listing. This will mean that the output for older posts may change as new related content gets added.
+
+toLower
+: Set to true to lower case keywords in both the indexes and the queries. This may give more accurate results at a slight performance penalty. Note that this can also be set per index.
+
+### Config Options per Index
+
+name
+: The index name. This value maps directly to a page param. Hugo supports string values (`author` in the example) and lists (`tags`, `keywords` etc.) and time and date objects.
+
+weight
+: An integer weight that indicates _how important_ this parameter is relative to the other parameters. It can be 0, which has the effect of turning this index off, or even negative. Test with different values to see what fits your content best.
+
+pattern
+: This is currently only relevant for dates. When listing related content, we may want to list content that is also close in time. Setting "2006" (default value for date indexes) as the pattern for a date index will add weight to pages published in the same year. For busier blogs, "200601" (year and month) may be a better default.
+
+toLower
+: See above.
+
+## Performance Considerations
+
+**Fast is Hugo's middle name** and we would not have released this feature had it not been blistering fast.
+
+This feature has been in the back log and requested by many for a long time. The development got this recent kick start from this Twitter thread:
+
+{{< tweet 898398437527363585 >}}
+
+Scott S. Lowe removed the "Related Content" section built using the `intersect` template function on tags, and the build time dropped from 30 seconds to less than 2 seconds on his 1700 content page sized blog.
+
+He should now be able to add an improved version of that "Related Content" section without giving up the fast live-reloads. But it's worth noting that:
+
+* If you don't use any of the `Related` methods, you will not use the Relate Content feature, and performance will be the same as before.
+* Calling `.RegularPages.Related` etc. will create one inverted index, also sometimes named posting list, that will be reused for any lookups in that same page collection. Doing that in addition to, as an example, calling `.Pages.Related` will work as expected, but will create one additional inverted index. This should still be very fast, but worth having in mind, especially for bigger sites.
+
++{{% note %}}
++We currently do not index **Page content**. We thought we would release something that will make most people happy before we start solving [Sherlock's last case](https://github.com/joearms/sherlock).
++{{% /note %}}
--- /dev/null
- * Hugo-defined Summary Split
- * User-defined Summary Split
+---
+title: Content Summaries
+linktitle: Summaries
+description: Hugo generates summaries of your content.
+date: 2017-01-10
+publishdate: 2017-01-10
+lastmod: 2017-01-10
+categories: [content management]
+keywords: [summaries,abstracts,read more]
+menu:
+ docs:
+ parent: "content-management"
+ weight: 90
+weight: 90 #rem
+draft: false
+aliases: [/content/summaries/,/content-management/content-summaries/]
+toc: true
+---
+
+With the use of the `.Summary` [page variable][pagevariables], Hugo generates summaries of content to use as a short version in summary views.
+
+## Summary Splitting Options
+
- ### Hugo-defined: Automatic Summary Splitting
++* Automatic Summary Split
++* Manual Summary Split
+
+It is natural to accompany the summary with links to the original content, and a common design pattern is to see this link in the form of a "Read More ..." button. See the `.RelPermalink`, `.Permalink`, and `.Truncated` [page variables][pagevariables].
+
- By default, Hugo automatically takes the first 70 words of your content as its summary and stores it into the `.Summary` page variable for use in your templates. Taking the Hugo-defined approach to summaries may save time, but it has pros and cons:
++### Automatic Summary Splitting
+
- * **Pros:** Automatic, no additional work on your part.
- * **Cons:** All HTML tags are stripped from the summary, and the first 70 words, whether they belong to a heading or to different paragraphs, are all put into one paragraph.
++By default, Hugo automatically takes the first 70 words of your content as its summary and stores it into the `.Summary` page variable for use in your templates. You may customize the summary length by setting `summaryLength` in your [site configuration](/getting-started/configuration/).
+
- The Hugo-defined summaries are set to use word count calculated by splitting the text by one or more consecutive white space characters. If you are creating content in a `CJK` language and want to use Hugo's automatic summary splitting, set `hasCJKLanguage` to `true` in you [site configuration](/getting-started/configuration/).
++{{% note %}}
++You can customize how HTML tags in the summary are loaded using functions such as `plainify` and `safeHTML`.
++{{% /note %}}
+
+{{% note %}}
- ### User-defined: Manual Summary Splitting
++The Hugo-defined summaries are set to use word count calculated by splitting the text by one or more consecutive whitespace characters. If you are creating content in a `CJK` language and want to use Hugo's automatic summary splitting, set `hasCJKLanguage` to `true` in your [site configuration](/getting-started/configuration/).
+{{% /note %}}
+
- Alternatively, you may add the <code><!--more--></code> summary divider where you want to split the article. For [org content][org], use `# more` where you want to split the article. Content that comes before the summary divider will be used as that content's summary and stored in the `.Summary` page variable with all HTML formatting intact.
++### Manual Summary Splitting
++
++Alternatively, you may add the <code><!--more--></code> summary divider where you want to split the article.
+
- * Pros: Freedom, precision, and improved rendering. All HTML tags and formatting are preserved.
- * Cons: Extra work for content authors, since they need to remember to type <code><!--more--></code> (or `# more` for [org content][org]) in each content file. This can be automated by adding the summary divider below the front matter of an [archetype](/content-management/archetypes/).
++For [Org mode content][org], use `# more` where you want to split the article.
++
++Content that comes before the summary divider will be used as that content's summary and stored in the `.Summary` page variable with all HTML formatting intact.
+
+{{% note "Summary Divider"%}}
+The concept of a *summary divider* is not unique to Hugo. It is also called the "more tag" or "excerpt separator" in other literature.
+{{% /note %}}
+
++Pros
++: Freedom, precision, and improved rendering. All HTML tags and formatting are preserved.
++
++Cons
++: Extra work for content authors, since they need to remember to type <code><!--more--></code> (or `# more` for [org content][org]) in each content file. This can be automated by adding the summary divider below the front matter of an [archetype](/content-management/archetypes/).
+
+{{% warning "Be Precise with the Summary Divider" %}}
+Be careful to enter <code><!--more--></code> exactly; i.e., all lowercase and with no whitespace.
+{{% /warning %}}
+
+## Example: First 10 Articles with Summaries
+
+You can show content summaries with the following code. You could use the following snippet, for example, in a [section template][].
+
+{{< code file="page-list-with-summaries.html" >}}
+{{ range first 10 .Pages }}
+ <article>
+ <!-- this <div> includes the title summary -->
+ <div>
+ <h2><a href="{{ .RelPermalink }}">{{ .Title }}</a></h2>
+ {{ .Summary }}
+ </div>
+ {{ if .Truncated }}
+ <!-- This <div> includes a read more link, but only if the summary is truncated... -->
+ <div>
+ <a href="{{ .RelPermalink }}">Read More…</a>
+ </div>
+ {{ end }}
+ </article>
+{{ end }}
+{{< /code >}}
+
+Note how the `.Truncated` boolean valuable may be used to hide the "Read More..." link when the content is not truncated; i.e., when the summary contains the entire article.
+
+[org]: /content-management/formats/
+[pagevariables]: /variables/page/
+[section template]: /templates/section-templates/
--- /dev/null
- aliases: [/contribute/development/]
+---
+title: Contribute to Hugo Development
+linktitle: Development
+description: Hugo relies heavily on contributions from the open source community.
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-02-01
+categories: [contribute]
+keywords: [dev,open source]
+authors: [digitalcraftsman]
+menu:
+ docs:
+ parent: "contribute"
+ weight: 10
+weight: 10
+sections_weight: 10
+draft: false
+toc: true
+---
+
+## Introduction
+
+Hugo is an open-source project and lives by the work of its [contributors][]. There are plenty of [open issues][issues], and we need your help to make Hugo even more awesome. You don't need to be a Go guru to contribute to the project's development.
+
+## Assumptions
+
+This contribution guide takes a step-by-step approach in hopes of helping newcomers. Therefore, we only assume the following:
+
+* You are new to Git or open-source projects in general
+* You are a fan of Hugo and enthusiastic about contributing to the project
+
+{{% note "Additional Questions?" %}}
+If you're struggling at any point in this contribution guide, reach out to the Hugo community in [Hugo's Discussion forum](https://discourse.gohugo.io).
+{{% /note %}}
+
+## Install Go
+
+The installation of Go should take only a few minutes. You have more than one option to get Go up and running on your machine.
+
+If you are having trouble following the installation guides for Go, check out [Go Bootcamp, which contains setups for every platform][gobootcamp] or reach out to the Hugo community in the [Hugo Discussion Forums][forums].
+
+### Install Go From Source
+
+[Download the latest stable version of Go][godl] and follow the official [Go installation guide][goinstall].
+
+Once you're finished installing Go, let's confirm everything is working correctly. Open a terminal---or command line under Windows--and type the following:
+
+```
+go version
+```
+
+You should see something similar to the following written to the console. Note that the version here reflects the most recent version of Go as of the last update for this page:
+
+```
+go version go1.8 darwin/amd64
+```
+
+Next, make sure that you set up your `GOPATH` [as described in the installation guide][setupgopath].
+
+You can print the `GOPATH` with `echo $GOPATH`. You should see a non-empty string containing a valid path to your Go workspace; for example:
+
+```
+/Users/<yourusername>/Code/go
+```
+
+### Install Go with Homebrew
+
+If you are a MacOS user and have [Homebrew](https://brew.sh/) installed on your machine, installing Go is as simple as the following command:
+
+{{< code file="install-go.sh" >}}
+brew install go
+{{< /code >}}
+
+### Install Go via GVM
+
+More experienced users can use the [Go Version Manager][gvm] (GVM). GVM allows you to switch between different Go versions *on the same machine*. If you're a beginner, you probably don't need this feature. However, GVM makes it easy to upgrade to a new released Go version with just a few commands.
+
+GVM comes in especially handy if you follow the development of Hugo over a longer period of time. Future versions of Hugo will usually be compiled with the latest version of Go. Sooner or later, you will have to upgrade if you want to keep up.
+
+## Create a GitHub Account
+
+If you're going to contribute code, you'll need to have an account on GitHub. Go to [www.github.com/join](https://github.com/join) and set up a personal account.
+
+## Install Git on Your System
+
+You will need to have Git installed on your computer to contribute to Hugo development. Teaching Git is outside the scope of the Hugo docs, but if you're looking for an excellent reference to learn the basics of Git, we recommend the [Git book][gitbook] if you are not sure where to begin. We will include short explainations of the Git commands in this document.
+
+Git is a [version control system](https://en.wikipedia.org/wiki/Version_control) to track the changes of source code. Hugo depends on smaller third-party packages that are used to extend the functionality. We use them because we don't want to reinvent the wheel.
+
+Go ships with a sub-command called `get` that will download these packages for us when we setup our working environment. The source code of the packages is tracked with Git. `get` will interact with the Git servers of the package hosters in order to fetch all dependencies.
+
+Move back to the terminal and check if Git is already installed. Type in `git version` and press enter. You can skip the rest of this section if the command returned a version number. Otherwise [download](https://git-scm.com/downloads) the latest version of Git and follow this [installation guide](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git).
+
+Finally, check again with `git version` if Git was installed successfully.
+
+### Git Graphical Front Ends
+
+There are several [GUI clients](https://git-scm.com/downloads/guis) that help you to operate Git. Not all are available for all operating systems and maybe differ in their usage. Because of this we will document how to use the command line, since the commands are the same everywhere.
+
+### Install Hub on Your System (Optional)
+
+Hub is a great tool for working with GitHub. The main site for it is [hub.github.com](https://hub.github.com/). Feel free to install this little Git wrapper.
+
+On a Mac, you can install [Hub](https://github.com/github/hub) using [Homebrew](https://brew.sh):
+
+```
+brew install hub
+```
+
+Now we'll create an [alias in Bash](http://tldp.org/LDP/abs/html/aliases.html) so that typing `git` actually runs `Hub`:
+
+```
+echo "alias git='hub'" >> ~/.bash_profile
+```
+
+Confirm the installation:
+
+```
+git version 2.6.3
+hub version 2.2.2
+```
+
+## Set up your working copy
+
+You set up the working copy of the repository locally on your computer. Your local copy of the files is what you'll edit, compile, and end up pushing back to GitHub. The main steps are cloning the repository and creating your fork as a remote.
+
+### Clone the repository
+
+We assume that you've set up your `GOPATH` (see the section above if you're unsure about this). You should now copy the Hugo repository down to your computer. You'll hear this called "clone the repo". GitHub's [help pages](https://help.github.com/articles/cloning-a-repository/) give us a short explanation:
+
+> When you create a repository on GitHub, it exists as a remote repository. You can create a local clone of your repository on your computer and sync between the two locations.
+
+We're going to clone the [master Hugo repository](https://github.com/gohugoio/hugo). That seems counter-intuitive, since you won't have commit rights on it. But it's required for the Go workflow. You'll work on a copy of the master and push your changes to your own repository on GitHub.
+
+So, let's clone that master repository:
+
+```
+go get -v -u github.com/gohugoio/hugo
+```
+
+Hugo relies on [Testify](https://github.com/stretchr/testify) for testing Go code. If you don't already have it, get the Testify testing tools:
+
+```
+go get github.com/stretchr/testify
+```
+
+### Fork the repository
+
+If you're not familiar with this term, GitHub's [help pages](https://help.github.com/articles/fork-a-repo/) provide again a simple explanation:
+
+> A fork is a copy of a repository. Forking a repository allows you to freely experiment with changes without affecting the original project.
+
+#### Fork by hand
+
+Open the [Hugo repository](https://github.com/gohugoio/hugo) on GitHub and click on the "Fork" button in the top right.
+
+
+
+Now open your fork repository on GitHub and copy the remote url of your fork. You can choose between HTTPS and SSH as protocol that Git should use for the following operations. HTTPS works always [if you're not sure](https://help.github.com/articles/which-remote-url-should-i-use/).
+
+
+
+Switch back to the terminal and move into the directory of the cloned master repository from the last step.
+
+```
+cd $GOPATH/src/github.com/gohugoio/hugo
+```
+
+Now Git needs to know that our fork exists by adding the copied remote url:
+
+```
+git remote add <YOUR-GITHUB-USERNAME> <COPIED REMOTE-URL>
+```
+
+#### Fork with Hub
+
+Alternatively, you can use the Git wrapper Hub. Hub makes forking a repository easy:
+
+```
+git fork
+```
+
+That command will log in to GitHub using your account, create a fork of the repository that you're currently working in, and add it as a remote to your working copy.
+
+#### Trust, but verify
+
+Let's check if everything went right by listing all known remotes:
+
+```
+git remote -v
+```
+
+The output should look similar:
+
+```
+digitalcraftsman git@github.com:digitalcraftsman/hugo.git (fetch)
+digitalcraftsman git@github.com:digitalcraftsman/hugo.git (push)
+origin https://github.com/gohugoio/hugo (fetch)
+origin https://github.com/gohugoio/hugo (push)
+```
+
+## The Hugo Git Contribution Workflow
+
+### Create a new branch
+
+You should never develop against the "master" branch. The development team will not accept a pull request against that branch. Instead, create a descriptive named branch and work on it.
+
+First, you should always pull the latest changes from the master repository:
+
+```
+git checkout master
+git pull
+```
+
+Now we can create a new branch for your additions:
+
+```
+git checkout -b <BRANCH-NAME>
+```
+
+You can check on which branch you are with `git branch`. You should see a list of all local branches. The current branch is indicated with a little asterisk.
+
+### Contribute to Documentation
+
+Perhaps you want to start contributing to the Hugo docs. If so, you can ignore most of the following steps and focus on the `/docs` directory within your newly cloned repository. You can change directories into the Hugo docs using `cd docs`.
+
+You can start Hugo's built-in server via `hugo server`. Browse the documentation by entering [http://localhost:1313](http://localhost:1313) in the address bar of your browser. The server automatically updates the page whenever you change content.
+
+We have developed a [separate Hugo documentation contribution guide][docscontrib] for more information on how the Hugo docs are built, organized, and improved by the generosity of people like you.
+
+### Build Hugo
+
+While making changes in the codebase it's a good idea to build the binary to test them:
+
+```
+go build -o hugo main.go
+```
+
+### Test
+Sometimes changes on the codebase can cause unintended side effects. Or they don't work as expected. Most functions have their own test cases. You can find them in files ending with `_test.go`.
+
+Make sure the commands `go test ./...` passes, and `go build` completes.
+
+### Formatting
+The Go code styleguide maybe is opinionated but it ensures that the codebase looks the same, regardless who wrote the code. Go comes with its own formatting tool. Let's apply the styleguide to our addtions:
+
+```
+go fmt ./...
+```
+
+Once you made your additions commit your changes. Make sure that you follow our [code contribution guidelines](https://github.com/gohugoio/hugo/blob/master/CONTRIBUTING.md):
+
+```
+# Add all changed files
+git add --all
+git commit --message "YOUR COMMIT MESSAGE"
+```
+
+The commit message should describe what the commit does (e.g. add feature XYZ), not how it is done.
+
+### Modify commits
+
+You noticed some commit messages don't fulfill the code contribution guidelines or you just forget something to add some files? No problem. Git provides the necessary tools to fix such problems. The next two methods cover all common cases.
+
+If you are unsure what a command does leave the commit as it is. We can fix your commits later in the pull request.
+
+#### Modify the last commit
+
+Let's say you want to modify the last commit message. Run the following command and replace the current message:
+
+```
+git commit --amend -m"YOUR NEW COMMIT MESSAGE"
+```
+
+Take a look at the commit log to see the change:
+
+```
+git log
+# Exit with q
+```
+
+After making the last commit you may have forgot something. There is no need to create a new commit. Just add the latest changes and merge them into the intended commit:
+
+```
+git add --all
+git commit --amend
+```
+
+#### Modify multiple commits
+
+{{% warning "Be Careful Modifying Multiple Commits"%}}
+Modifications such as those described in this section can have serious unintended consequences. Skip this section if you're not sure!
+{{% /warning %}}
+
+This is a bit more advanced. Git allows you to [rebase](https://git-scm.com/docs/git-rebase) commits interactively. In other words: it allows you to rewrite the commit history.
+
+```
+git rebase --interactive @~6
+```
+
+The `6` at the end of the command represents the number of commits that should be modified. An editor should open and present a list of last six commit messages:
+
+```
+pick 80d02a1 tpl: Add hasPrefix to the template funcs' "smoke test"
+pick aaee038 tpl: Sort the smoke tests
+pick f0dbf2c tpl: Add the other test case for hasPrefix
+pick 911c35b Add "How to contribute to Hugo" tutorial
+pick 33c8973 Begin workflow
+pick 3502f2e Refactoring and typo fixes
+```
+
+In the case above we should merge the last to commits in the commit of this tutorial (`Add "How to contribute to Hugo" tutorial`). You can "squash" commits, i.e. merge two or more commits into a single one.
+
+All operations are written before the commit message. Replace "pick" with an operation. In this case `squash` or `s` for short:
+
+```
+pick 80d02a1 tpl: Add hasPrefix to the template funcs' "smoke test"
+pick aaee038 tpl: Sort the smoke tests
+pick f0dbf2c tpl: Add the other test case for hasPrefix
+pick 911c35b Add "How to contribute to Hugo" tutorial
+squash 33c8973 Begin workflow
+squash 3502f2e Refactoring and typo fixes
+```
+
+We also want to rewrite the commits message of the third last commit. We forgot "docs:" as prefix according to the code contribution guidelines. The operation to rewrite a commit is called `reword` (or `r` as shortcut).
+
+You should end up with a similar setup:
+
+```
+pick 80d02a1 tpl: Add hasPrefix to the template funcs' "smoke test"
+pick aaee038 tpl: Sort the smoke tests
+pick f0dbf2c tpl: Add the other test case for hasPrefix
+reword 911c35b Add "How to contribute to Hugo" tutorial
+squash 33c8973 Begin workflow
+squash 3502f2e Refactoring and typo fixes
+```
+
+Close the editor. It should open again with a new tab. A text is instructing you to define a new commit message for the last two commits that should be merged (aka "squashed"). Save the file with <kbd>CTRL</kbd>+<kbd>S</kbd> and close the editor again.
+
+A last time a new tab opens. Enter a new commit message and save again. Your terminal should contain a status message. Hopefully this one:
+
+```
+Successfully rebased and updated refs/heads/<BRANCHNAME>.
+```
+
+Check the commit log if everything looks as expected. Should an error occur you can abort this rebase with `git rebase --abort`.
+
+### Push commits
+
+To push our commits to the fork on GitHub we need to specify a destination. A destination is defined by the remote and a branch name. Earlier, the defined that the remote url of our fork is the same as our GitHub handle, in my case `digitalcraftsman`. The branch should have the same as our local one. This makes it easy to identify corresponding branches.
+
+```
+git push --set-upstream <YOUR-GITHUB-USERNAME> <BRANCHNAME>
+```
+
+Now Git knows the destination. Next time when you to push commits you just need to enter `git push`.
+
+If you modified your commit history in the last step GitHub will reject your try to push. This is a safety-feature because the commit history isn't the same and new commits can't be appended as usual. You can enforce this push explicitly with `git push --force`.
+
+## Open a pull request
+
+We made a lot of progress. Good work. In this step we finally open a pull request to submit our additions. Open the [Hugo master repository](https://github.com/gohugoio/hugo/) on GitHub in your browser.
+
+You should find a green button labeled with "New pull request". But GitHub is clever and probably suggests you a pull request like in the beige box below:
+
+
+
+The new page summaries the most important information of your pull request. Scroll down and you find the additions of all your commits. Make sure everything looks as expected and click on "Create pull request".
+
+### Accept the contributor license agreement
+
+Last but not least you should accept the contributor license agreement (CLA). A new comment should be added automatically to your pull request. Click on the yellow badge, accept the agreement and authenticate yourself with your GitHub account. It just takes a few clicks and only needs to be done once.
+
+
+
+### Automatic builds
+
+We use the [Travis CI loop](https://travis-ci.org/gohugoio/hugo) (Linux and OS X) and [AppVeyor](https://ci.appveyor.com/project/gohugoio/hugo/branch/master) (Windows) to compile Hugo with your additions. This should ensure that everything works as expected before merging your pull request. This in most cases only relevant if you made changes to the codebase of Hugo.
+
+
+
+Above you can see that Travis wasn't able to compile the changes in this pull request. Click on "Details" and try to investigate why the build failed. But it doesn't have to be your fault. Mostly, the `master` branch that we used as foundation for your pull request should build without problems.
+
+If you have questions, leave a comment in the pull request. We are willing to assist you.
+
+## Where to start?
+
+Thank you for reading through this contribution guide. Hopefully, we will see you again soon on GitHub. There are plenty of [open issues][issues] for you to help with.
+
+Feel free to [open an issue][newissue] if you think you found a bug or you have a new idea to improve Hugo. We are happy to hear from you.
+
+## Additional References for Learning Git and Go
+
+* [Codecademy's Free "Learn Git" Course][codecademy] (Free)
+* [Code School and GitHub's "Try Git" Tutorial][trygit] (Free)
+* [The Git Book][gitbook] (Free)
+* [Go Bootcamp][gobootcamp]
+* [GitHub Pull Request Tutorial, Thinkful][thinkful]
+
+
+[codecademy]: https://www.codecademy.com/learn/learn-git
+[contributors]: https://github.com/gohugoio/hugo/graphs/contributors
+[docscontrib]: /contribute/documentation/
+[forums]: https://discourse.gohugo.io
+[gitbook]: https://git-scm.com/
+[gobootcamp]: http://www.golangbootcamp.com/book/get_setup
+[godl]: https://golang.org/dl/
+[goinstall]: https://golang.org/doc/install
+[gvm]: https://github.com/moovweb/gvm
+[issues]: https://github.com/gohugoio/hugo/issues
+[newissue]: https://github.com/gohugoio/hugo/issues/new
+[releases]: /getting-started/
+[setupgopath]: https://golang.org/doc/code.html#Workspaces
+[thinkful]: https://www.thinkful.com/learn/github-pull-request-tutorial/
+[trygit]: https://try.github.io/levels/1/challenges/1
--- /dev/null
- Across all pages on the Hugo docs, the typical triple-back-tick markdown syntax is used. If you do not want to take the extra time to implement the following code block shortcodes, please use standard GitHub-flavored markdown. The Hugo docs use a version of [highlight.js](https://highlightjs.org/) with a specific set of languages.
+---
+title: Contribute to the Hugo Docs
+linktitle: Documentation
+description: Documentation is an integral part of any open source project. The Hugo docs are as much a work in progress as the source it attempts to cover.
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-02-01
+categories: [contribute]
+keywords: [docs,documentation,community, contribute]
+menu:
+ docs:
+ parent: "contribute"
+ weight: 20
+weight: 20
+sections_weight: 20
+draft: false
+aliases: [/contribute/docs/]
+toc: true
+---
+
+## Create Your Fork
+
+It's best to make changes to the Hugo docs on your local machine to check for consistent visual styling. Make sure you've created a fork of [hugoDocs](https://github.com/gohugoio/hugoDocs) on GitHub and cloned the repository locally on your machine. For more information, you can see [GitHub's documentation on "forking"][ghforking] or follow along with [Hugo's development contribution guide][hugodev].
+
+You can then create a separate branch for your additions. Be sure to choose a descriptive branch name that best fits the type of content. The following is an example of a branch name you might use for adding a new website to the showcase:
+
+```
+git checkout -b jon-doe-showcase-addition
+```
+
+## Add New Content
+
+The Hugo docs make heavy use of Hugo's [archetypes][] feature. All content sections in Hugo documentation have an assigned archetype.
+
+Adding new content to the Hugo docs follows the same pattern, regardless of the content section:
+
+```
+hugo new <DOCS-SECTION>/<new-content-lowercase>.md
+```
+
+### Add a New Function
+
+Once you have cloned the Hugo repository, you can create a new function via the following command. Keep the file name lowercase.
+
+```
+hugo new functions/newfunction.md
+```
+
+The archetype for `functions` according to the Hugo docs is as follows:
+
+{{< code file="archetypes/functions.md" >}}
+{{< readfile file="/archetypes/functions.md">}}
+{{< /code >}}
+
+#### New Function Required Fields
+
+Here is a review of the front matter fields automatically generated for you using `hugo new functions/*`:
+
+***`title`***
+: this will be auto-populated in all lowercase when you use `hugo new` generator.
+
+***`linktitle`***
+: the function's actual casing (e.g., `replaceRE` rather than `replacere`).
+
+***`description`***
+: a brief description used to populate the [Functions Quick Reference](/functions/).
+
+`categories`
+: currently auto-populated with 'functions` for future-proofing and portability reasons only; ignore this field.
+
+`tags`
+: only if you think it will help end users find other related functions
+
+`signature`
+: this is a signature/syntax definition for calling the function (e.g., `apply SEQUENCE FUNCTION [PARAM...]`).
+
+`workson`
+: acceptable values include `lists`,`taxonomies`, `terms`, `groups`, and `files`.
+
+`hugoversion`
+: the version of Hugo that will ship with this new function.
+
+`relatedfuncs`
+: other [templating functions][] you feel are related to your new function to help fellow Hugo users.
+
+`{{.Content}}`
+: an extended description of the new function; examples are not only welcomed but encouraged.
+
+In the body of your function, expand the short description used in the front matter. Include as many examples as possible, and leverage the Hugo docs [`code` shortcode](#adding-code-blocks). If you are unable to add examples but would like to solicit help from the Hugo community, add `needsexample: true` to your front matter.
+
+## Add Code Blocks
+
+Code blocks are crucial for providing examples of Hugo's new features to end users of the Hugo docs. Whenever possible, create examples that you think Hugo users will be able to implement in their own projects.
+
+### Standard Syntax
+
- ```
++Across many pages on the Hugo docs, the typical triple-back-tick markdown syntax (```` ``` ````) is used. If you do not want to take the extra time to implement the following code block shortcodes, please use standard GitHub-flavored markdown. The Hugo docs use a version of [highlight.js](https://highlightjs.org/) with a specific set of languages.
+
+Your options for languages are `xml`/`html`, `go`/`golang`, `md`/`markdown`/`mkd`, `handlebars`, `apache`, `toml`, `yaml`, `json`, `css`, `asciidoc`, `ruby`, `powershell`/`ps`, `scss`, `sh`/`zsh`/`bash`/`git`, `http`/`https`, and `javascript`/`js`.
+
- ```
++````
+```
+<h1>Hello world!</h1>
+```
- ```
++````
+
+### Code Block Shortcode
+
+The Hugo documentation comes with a very robust shortcode for adding interactive code blocks.
+
+{{% note %}}
+With the `code` shortcodes, *you must include triple back ticks and a language declaration*. This was done by design so that the shortcode wrappers were easily added to legacy documentation and will be that much easier to remove if needed in future versions of the Hugo docs.
+{{% /note %}}
+
+### `code`
+
+`code` is the Hugo docs shortcode you'll use most often. `code` requires has only one named parameter: `file`. Here is the pattern:
+
+```
+{{%/* code file="smart/file/name/with/path.html" download="download.html" copy="true" */%}}
- ```
+A whole bunch of coding going on up in here!
- ```
+{{%/* /code */%}}
+```
+
+The following are the arguments passed into `code`:
+
++
+***`file`***
+: the only *required* argument. `file` is needed for styling but also plays an important role in helping users create a mental model around Hugo's directory structure. Visually, this will be displayed as text in the top left of the code block.
+
+`download`
+: if omitted, this will have no effect on the rendered shortcode. When a value is added to `download`, it's used as the filename for a downloadable version of the code block.
+
+`copy`
+: a copy button is added automatically to all `code` shortcodes. If you want to keep the filename and styling of `code` but don't want to encourage readers to copy the code (e.g., a "Do not do" snippet in a tutorial), use `copy="false"`.
+
+#### Example `code` Input
+
+This example HTML code block tells Hugo users the following:
+
+1. This file *could* live in `layouts/_default`, as demonstrated by `layouts/_default/single.html` as the value for `file`.
+2. This snippet is complete enough to be downloaded and implemented in a Hugo project, as demonstrated by `download="single.html"`.
+
+```
+{{</* code file="layouts/_default/single.html" download="single.html" */>}}
+{{ define "main" }}
+<main>
+ <article>
+ <header>
+ <h1>{{.Title}}</h1>
+ {{with .Params.subtitle}}
+ <span>{{.}}</span>
+ </header>
+ <div>
+ {{.Content}}
+ </div>
+ <aside>
+ {{.TableOfContents}}
+ </aside>
+ </article>
+</main>
+{{ end }}
+{{</* /code */>}}
+```
+
+##### Example 'code' Display
+
+The output of this example will render to the Hugo docs as follows:
+
+{{< code file="layouts/_default/single.html" download="single.html" >}}
+{{ define "main" }}
+<main>
+ <article>
+ <header>
+ <h1>{{.Title}}</h1>
+ {{with .Params.subtitle}}
+ <span>{{.}}</span>
+ </header>
+ <div>
+ {{.Content}}
+ </div>
+ <aside>
+ {{.TableOfContents}}
+ </aside>
+ </article>
+</main>
+{{ end }}
+{{< /code >}}
+
+<!-- #### Output Code Block
+
+The `output` shortcode is almost identical to the `code` shortcode but only takes and requires `file`. The purpose of `output` is to show *rendered* HTML and therefore almost always follows another basic code block *or* and instance of the `code` shortcode:
+
+```
+{{%/* output file="post/my-first-post/index.html" */%}}
- ```
+<h1>This is my First Hugo Blog Post</h1>
+<p>I am excited to be using Hugo.</p>
+{{%/* /output */%}}
+```
+
+The preceding `output` example will render as follows to the Hugo docs:
+
+{{< output file="post/my-first-post/index.html" >}}
+<h1>This is my First Hugo Blog Post</h1>
+<p>I am excited to be using Hugo.</p>
+{{< /output >}} -->
+
+## Blockquotes
+
+Blockquotes can be added to the Hugo documentation using [typical Markdown blockquote syntax][bqsyntax]:
+
+```
+> Without the threat of punishment, there is no joy in flight.
+```
+
+The preceding blockquote will render as follows in the Hugo docs:
+
+> Without the threat of punishment, there is no joy in flight.
+
+However, you can add a quick and easy `<cite>` element (added on the client via JavaScript) by separating your main blockquote and the citation with a hyphen with a single space on each side:
+
+```
+> Without the threat of punishment, there is no joy in flight. - [Kobo Abe](https://en.wikipedia.org/wiki/Kobo_Abe)
+```
+
+Which will render as follows in the Hugo docs:
+
+> Without the threat of punishment, there is no joy in flight. - [Kobo Abe][abe]
+
+{{% note "Blockquotes `!=` Admonitions" %}}
+Previous versions of Hugo documentation used blockquotes to draw attention to text. This is *not* the [intended semantic use of `<blockquote>`](http://html5doctor.com/cite-and-blockquote-reloaded/). Use blockquotes when quoting. To note or warn your user of specific information, use the admonition shortcodes that follow.
+{{% /note %}}
+
+## Admonitions
+
+**Admonitions** are common in technical documentation. The most popular is that seen in [reStructuredText Directives][sourceforge]. From the SourceForge documentation:
+
+> Admonitions are specially marked "topics" that can appear anywhere an ordinary body element can. They contain arbitrary body elements. Typically, an admonition is rendered as an offset block in a document, sometimes outlined or shaded, with a title matching the admonition type. - [SourceForge][sourceforge]
+
+The Hugo docs contain three admonitions: `note`, `tip`, and `warning`.
+
+### `note` Admonition
+
+Use the `note` shortcode when you want to draw attention to information subtly. `note` is intended to be less of an interruption in content than is `warning`.
+
+#### Example `note` Input
+
+{{< code file="note-with-heading.md" >}}
+{{%/* note */%}}
+Here is a piece of information I would like to draw your **attention** to.
+{{%/* /note */%}}
+{{< /code >}}
+
+#### Example `note` Output
+
+{{< output file="note-with-heading.html" >}}
+{{% note %}}
+Here is a piece of information I would like to draw your **attention** to.
+{{% /note %}}
+{{< /output >}}
+
+#### Example `note` Display
+
+{{% note %}}
+Here is a piece of information I would like to draw your **attention** to.
+{{% /note %}}
+
+### `tip` Admonition
+
+Use the `tip` shortcode when you want to give the reader advice. `tip`, like `note`, is intended to be less of an interruption in content than is `warning`.
+
+#### Example `tip` Input
+
+{{< code file="using-tip.md" >}}
+{{%/* tip */%}}
+Here's a bit of advice to improve your productivity with Hugo.
+{{%/* /tip */%}}
+{{< /code >}}
+
+#### Example `tip` Output
+
+{{< output file="tip-output.html" >}}
+{{% tip %}}
+Here's a bit of advice to improve your productivity with Hugo.
+{{% /tip %}}
+{{< /output >}}
+
+#### Example `tip` Display
+
+{{% tip %}}
+Here's a bit of advice to improve your productivity with Hugo.
+{{% /tip %}}
+
+### `warning` Admonition
+
+Use the `warning` shortcode when you want to draw the user's attention to something important. A good usage example is for articulating breaking changes in Hugo versions, known bugs, or templating "gotchas."
+
+#### Example `warning` Input
+
+{{< code file="warning-admonition-input.md" >}}
+{{%/* warning */%}}
+This is a warning, which should be reserved for *important* information like breaking changes.
+{{%/* /warning */%}}
+{{< /code >}}
+
+#### Example `warning` Output
+
+{{< output file="warning-admonition-output.html" >}}
+{{% warning %}}
+This is a warning, which should be reserved for *important* information like breaking changes.
+{{% /warning %}}
+{{< /output >}}
+
+#### Example `warning` Display
+
+{{% warning %}}
+This is a warning, which should be reserved for *important* information like breaking changes.
+{{% /warning %}}
+
+{{% note "Pull Requests and Branches" %}}
+Similar to [contributing to Hugo development](/contribute/development/), the Hugo team expects you to create a separate branch/fork when you make your contributions to the Hugo docs.
+{{% /note %}}
+
+[abe]: https://en.wikipedia.org/wiki/Kobo_Abe
+[archetypes]: /content-management/archetypes/
+[bqsyntax]: https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet#blockquotes
+[charcount]: http://www.lettercount.com/
+[`docs/static/images/showcase/`]: https://github.com/gohugoio/hugo/tree/master/docs/static/images/showcase/
+[ghforking]: https://help.github.com/articles/fork-a-repo/
+[hugodev]: /contribute/development/
+[shortcodeparams]: content-management/shortcodes/#shortcodes-without-markdown
+[sourceforge]: http://docutils.sourceforge.net/docs/ref/rst/directives.html#admonitions
+[templating function]: /functions/
--- /dev/null
- To fund a regular page in the blog section::
+---
+title: .GetPage
+description: "Gets a `Page` of a given `path`."
+godocref:
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-02-01
+categories: [functions]
+menu:
+ docs:
+ parent: "functions"
+keywords: [sections,lists,indexes]
+signature: [".GetPage PATH"]
+workson: []
+hugoversion:
+relatedfuncs: []
+deprecated: false
+aliases: []
+---
+
+`.GetPage` returns a page of a given `path`. Both `Site` and `Page` implements this method. The `Page` variant will, if given a relative path -- i.e. a path without a leading `/` -- try look for the page relative to the current page.
+
+{{% note %}}
+**Note:** We overhauled and simplified the `.GetPage` API in Hugo 0.45. Before that you needed to provide a `Kind` attribute in addition to the path, e.g. `{{ .Site.GetPage "section" "blog" }}`. This will still work, but is now superflous.
+{{% /note %}}
+
+
+```go-html-template
+{{ with .Site.GetPage "/blog" }}{{ .Title }}{{ end }}
+```
+
+This method wil return `nil` when no page could be found, so the above will not print anything if the blog section is not found.
+
++To find a regular page in the blog section::
+
+```go-html-template
+{{ with .Site.GetPage "/blog/my-post.md" }}{{ .Title }}{{ end }}
+```
+
+And since `Page` also provides a `.GetPage` method, the above is the same as:
+
+```go-html-template
+{{ with .Site.GetPage "/blog" }}
+{{ with .GetPage "my-post.md" }}{{ .Title }}{{ end }}
+{{ end }}
+```
+
+## .GetPage and Multilingual Sites
+
+The previous examples have used the full content filename to lookup the post. Depending on how you have organized your content (whether you have the language code in the file name or not, e.g. `my-post.en.md`), you may want to do the lookup without extension. This will get you the current language's version of the page:
+
+```go-html-template
+{{ with .Site.GetPage "/blog/my-post" }}{{ .Title }}{{ end }}
+```
+
+## .GetPage Example
+
+This code snippet---in the form of a [partial template][partials]---allows you to do the following:
+
+1. Grab the index object of your `tags` [taxonomy][].
+2. Assign this object to a variable, `$t`
+3. Sort the terms associated with the taxonomy by popularity.
+4. Grab the top two most popular terms in the taxonomy (i.e., the two most popular tags assigned to content.
+
+{{< code file="grab-top-two-tags.html" >}}
+<ul class="most-popular-tags">
+{{ $t := .Site.GetPage "/tags" }}
+{{ range first 2 $t.Data.Terms.ByCount }}
+ <li>{{ . }}</li>
+{{ end }}
+</ul>
+{{< /code >}}
+
+## `.GetPage` on Page Bundles
+
+If the page retrieved by `.GetPage` is a [Leaf Bundle][leaf_bundle], and you
+need to get the nested _**page** resources_ in that, you will need to use the
+methods in `.Resources` as explained in the [Page Resources][page_resources]
+section.
+
+See the [Headless Bundle][headless_bundle] documentation for an example.
+
+
+[partials]: /templates/partials/
+[taxonomy]: /content-management/taxonomies/
+[page_kinds]: /templates/section-templates/#page-kinds
+[leaf_bundle]: /content-management/page-bundles/#leaf-bundles
+[headless_bundle]: /content-management/page-bundles/#headless-bundle
+[page_resources]: /content-management/page-resources/
--- /dev/null
- `default` checks whether a given value is set and returns a default value if it is not. *Set* in this context means different things depending on date type:
+---
+title: default
+description: Allows setting a default value that can be returned if a first value is not set.
+qref: "Returns a default value if a value is not set when checked."
+godocref:
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-02-01
+keywords: [defaults]
+categories: [functions]
+menu:
+ docs:
+ parent: "functions"
+toc:
+signature: ["default DEFAULT INPUT"]
+workson: []
+hugoversion:
+relatedfuncs: []
+deprecated: false
+draft: false
+aliases: []
+needsexamples: false
+---
+
++`default` checks whether a given value is set and returns a default value if it is not. *Set* in this context means different things depending on the data type:
+
+* non-zero for numeric types and times
+* non-zero length for strings, arrays, slices, and maps
+* any boolean or struct value
+* non-nil for any other types
+
+`default` function examples reference the following content page:
+
+{{< code file="content/posts/default-function-example.md" >}}
+---
+title: Sane Defaults
+seo_title:
+date: 2017-02-18
+font:
+oldparam: The default function helps make your templating DRYer.
+newparam:
+---
+{{< /code >}}
+
+`default` can be written in more than one way:
+
+```
+{{ index .Params "font" | default "Roboto" }}
+{{ default "Roboto" (index .Params "font") }}
+```
+
+Both of the above `default` function calls return `Roboto`.
+
+A `default` value, however, does not need to be hard coded like the previous example. The `default` value can be a variable or pulled directly from the front matter using dot notation:
+
+{{< code file="variable-as-default-value.html" nocopy="true" >}}
+{{$old := .Params.oldparam }}
+<p>{{ .Params.newparam | default $old }}</p>
+{{< /code >}}
+
+Which would return:
+
+```
+<p>The default function helps make your templating DRYer.</p>
+```
+
+And then using dot notation
+
+{{< code file="dot-notation-default-value.html" >}}
+<title>{{ .Params.seo_title | default .Title }}</title>
+{{< /code >}}
+
+Which would return
+
+{{< output file="dot-notation-default-return-value.html" >}}
+<title>Sane Defaults</title>
+{{< /output >}}
+
+The following have equivalent return values but are far less terse. This demonstrates the utility of `default`:
+
+Using `if`:
+
+{{< code file="if-instead-of-default.html" nocopy="true" >}}
+<title>{{if .Params.seo_title}}{{.Params.seo_title}}{{else}}{{.Title}}{{end}}</title>
+=> Sane Defaults
+{{< /code >}}
+
+Using `with`:
+
+{{< code file="with-instead-of-default.html" nocopy="true" >}}
+<title>{{with .Params.seo_title}}{{.}}{{else}}{{.Title}}{{end}}</title>
+=> Sane Defaults
+{{< /code >}}
--- /dev/null
- The elements supported are strings, integers, and floats (only float64).
-
- A useful example of `intersect` functionality is a "related posts" block. `isset` allows us to create a list of links to other posts that have tags that intersect with the tags in the current post.
-
- The following is an example of a "related posts" [partial template][partials] that could be added to a [single page template][single]:
-
- {{< code file="layouts/partials/related-posts.html" download="related-posts.html" >}}
- <ul>
- {{ $page_link := .Permalink }}
- {{ $tags := .Params.tags }}
- {{ range .Site.Pages }}
- {{ $page := . }}
- {{ $has_common_tags := intersect $tags .Params.tags | len | lt 0 }}
- {{ if and $has_common_tags (ne $page_link $page.Permalink) }}
- <li><a href="{{ $page.Permalink }}">{{ $page.Title }}</a></li>
- {{ end }}
- {{ end }}
- </ul>
- {{< /code >}}
-
- This is also very useful to use as `AND` filters when combined with where:
+---
+title: intersect
+linktitle: intersect
+description: Returns the common elements of two arrays or slices.
+godocref:
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-02-01
+categories: [functions]
+menu:
+ docs:
+ parent: "functions"
+keywords: []
+signature: ["intersect SET1 SET2"]
+workson: []
+hugoversion:
+relatedfuncs: []
+deprecated: false
+aliases: []
+---
+
++An useful example is to use it as `AND` filters when combined with where:
+
+```
+{{ $pages := where .Site.RegularPages "Type" "not in" (slice "page" "about") }}
+{{ $pages := $pages | union (where .Site.RegularPages "Params.pinned" true) }}
+{{ $pages := $pages | intersect (where .Site.RegularPages "Params.images" "!=" nil) }}
+```
+
+The above fetches regular pages not of `page` or `about` type unless they are pinned. And finally, we exclude all pages with no `images` set in Page params.
+
+See [union](/functions/union) for `OR`.
+
+
+[partials]: /templates/partials/
+[single]: /templates/single-page-templates/
--- /dev/null
--- /dev/null
++---
++title: os.Stat
++description: Gets a file information of a given path.
++godocref:
++date: 2018-08-07
++publishdate: 2018-08-07
++lastmod: 2018-08-07
++categories: [functions]
++menu:
++ docs:
++ parent: "functions"
++keywords: [files]
++signature: ["os.Stat PATH"]
++workson: []
++hugoversion:
++relatedfuncs: [readDir]
++deprecated: false
++aliases: []
++---
++
++If your current project working directory has a single file named `README.txt` (30 bytes):
++```
++{{ $stat := os.Stat "README.txt" }}
++{{ $stat.Name }} → "README.txt"
++{{ $stat.Size }} → 30
++```
++
++Function [`os.Stat`][Stat] returns [`os.FileInfo`][osfileinfo].
++For further information of `os.FileInfo`, see [golang page][osfileinfo].
++
++
++[Stat]: /functions/os.Stat/
++[osfileinfo]: https://golang.org/pkg/os/#FileInfo
--- /dev/null
- 6. You should now have three new files: hugo executable (e.g. `hugo_0.18_windows_amd64.exe`), `license.md`, and `readme.md`. (You can delete the ZIP download now.) Rename that hugo executable (`hugo_hugo-version_platform_arch.exe`) to `hugo.exe` for ease of use.
+---
+title: Install Hugo
+linktitle: Install Hugo
+description: Install Hugo on macOS, Windows, Linux, OpenBSD, FreeBSD, and on any machine where the Go compiler tool chain can run.
+date: 2016-11-01
+publishdate: 2016-11-01
+lastmod: 2018-01-02
+categories: [getting started,fundamentals]
+authors: ["Michael Henderson"]
+keywords: [install,pc,windows,linux,macos,binary,tarball]
+menu:
+ docs:
+ parent: "getting-started"
+ weight: 30
+weight: 30
+sections_weight: 30
+draft: false
+aliases: [/tutorials/installing-on-windows/,/tutorials/installing-on-mac/,/overview/installing/,/getting-started/install,/install/]
+toc: true
+---
+
+
+{{% note %}}
+There is lots of talk about "Hugo being written in Go", but you don't need to install Go to enjoy Hugo. Just grab a precompiled binary!
+{{% /note %}}
+
+Hugo is written in [Go](https://golang.org/) with support for multiple platforms. The latest release can be found at [Hugo Releases][releases].
+
+Hugo currently provides pre-built binaries for the following:
+
+* macOS (Darwin) for x64, i386, and ARM architectures
+* Windows
+* Linux
+* OpenBSD
+* FreeBSD
+
+Hugo may also be compiled from source wherever the Go toolchain can run; e.g., on other operating systems such as DragonFly BSD, OpenBSD, Plan 9, Solaris, and others. See <https://golang.org/doc/install/source> for the full set of supported combinations of target operating systems and compilation architectures.
+
+## Quick Install
+
+### Binary (Cross-platform)
+
+Download the appropriate version for your platform from [Hugo Releases][releases]. Once downloaded, the binary can be run from anywhere. You don't need to install it into a global location. This works well for shared hosts and other systems where you don't have a privileged account.
+
+Ideally, you should install it somewhere in your `PATH` for easy use. `/usr/local/bin` is the most probable location.
+
+### Homebrew (macOS)
+
+If you are on macOS and using [Homebrew][brew], you can install Hugo with the following one-liner:
+
+{{< code file="install-with-homebrew.sh" >}}
+brew install hugo
+{{< /code >}}
+
+For more detailed explanations, read the installation guides that follow for installing on macOS and Windows.
+
+### Chocolatey (Windows)
+
+If you are on a Windows machine and use [Chocolatey][] for package management, you can install Hugo with the following one-liner:
+
+{{< code file="install-with-chocolatey.ps1" >}}
+choco install hugo -confirm
+{{< /code >}}
+
+### Scoop (Windows)
+
+If you are on a Windows machine and use [Scoop][] for package management, you can install Hugo with the following one-liner:
+
+```bash
+scoop install hugo
+```
+
+### Source
+
+#### Prerequisite Tools
+
+* [Git][installgit]
+* [Go (latest or previous version)][installgo]
+
+#### Vendored Dependencies
+
+Hugo uses [dep][] to vendor dependencies, but we don't commit the vendored packages themselves to the Hugo git repository. Therefore, a simple `go get` is *not* supported because the command is not vendor aware.
+
+The simplest way is to use [mage][] (a Make alternative for Go projects.)
+
+#### Fetch from GitHub
+
+{{< code file="from-gh.sh" >}}
+go get github.com/magefile/mage
+go get -d github.com/gohugoio/hugo
+cd ${GOPATH:-$HOME/go}/src/github.com/gohugoio/hugo
+mage vendor
+HUGO_BUILD_TAGS=extended mage install
+{{< /code >}}
+
+Remove `HUGO_BUILD_TAGS=extended` if you do not want Sass/SCSS support.
+
+{{% note %}}
+If you are a Windows user, substitute the `$HOME` environment variable above with `%USERPROFILE%`.
+{{% /note %}}
+
+## macOS
+
+### Assumptions
+
+1. You know how to open the macOS terminal.
+2. You're running a modern 64-bit Mac.
+3. You will use `~/Sites` as the starting point for your site. (`~/Sites` is used for example purposes. If you are familiar enough with the command line and file system, you should have no issues following along with the instructions.)
+
+### Pick Your Method
+
+There are three ways to install Hugo on your Mac
+
+1. The [Homebrew][brew] `brew` utility
+2. Distribution (i.e., tarball)
+3. Building from Source
+
+There is no "best" way to install Hugo on your Mac. You should use the method that works best for your use case.
+
+#### Pros and Cons
+
+There are pros and cons to each of the aforementioned methods:
+
+1. **Homebrew.** Homebrew is the simplest method and will require the least amount of work to maintain. The drawbacks aren't severe. The default package will be for the most recent release, so it will not have bug fixes until the next release (i.e., unless you install it with the `--HEAD` option). Hugo `brew` releases may lag a few days behind because it has to be coordinated with another team. Nevertheless, `brew` is the recommended installation method if you want to work from a stable, widely used source. Brew works well and is easy to update.
+
+2. **Tarball.** Downloading and installing from the tarball is also easy, although it requires a few more command line skills than does Homebrew. Updates are easy as well: you just repeat the process with the new binary. This gives you the flexibility to have multiple versions on your computer. If you don't want to use `brew`, then the tarball/binary is a good choice.
+
+3. **Building from Source.** Building from source is the most work. The advantage of building from source is that you don't have to wait for a release to add features or bug fixes. The disadvantage is that you need to spend more time managing the setup, which is manageable but requires more time than the preceding two options.
+
+{{% note %}}
+Since building from source is appealing to more seasoned command line users, this guide will focus more on installing Hugo via Homebrew and Tarball.
+{{% /note %}}
+
+### Install Hugo with Brew
+
+{{< youtube WvhCGlLcrF8 >}}
+
+#### Step 1: Install `brew` if you haven't already
+
+Go to the `brew` website, <https://brew.sh/>, and follow the directions there. The most important step is the installation from the command line:
+
+{{< code file="install-brew.sh" >}}
+ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
+{{< /code >}}
+
+#### Step 2: Run the `brew` Command to Install `hugo`
+
+Installing Hugo using `brew` is as easy as the following:
+
+{{< code file="install-brew.sh" >}}
+brew install hugo
+{{< /code >}}
+
+If Homebrew is working properly, you should see something similar to the following:
+
+```
+==> Downloading https://homebrew.bintray.com/bottles/hugo-0.21.sierra.bottle.tar.gz
+######################################################################### 100.0%
+==> Pouring hugo-0.21.sierra.bottle.tar.gz
+🍺 /usr/local/Cellar/hugo/0.21: 32 files, 17.4MB
+```
+
+{{% note "Installing the Latest Hugo with Brew" %}}
+Replace `brew install hugo` with `brew install hugo --HEAD` if you want the absolute latest in-development version.
+{{% /note %}}
+
+`brew` should have updated your path to include Hugo. You can confirm by opening a new terminal window and running a few commands:
+
+```
+$ # show the location of the hugo executable
+which hugo
+/usr/local/bin/hugo
+
+# show the installed version
+ls -l $( which hugo )
+lrwxr-xr-x 1 mdhender admin 30 Mar 28 22:19 /usr/local/bin/hugo -> ../Cellar/hugo/0.13_1/bin/hugo
+
+# verify that hugo runs correctly
+hugo version
+Hugo Static Site Generator v0.13 BuildDate: 2015-03-09T21:34:47-05:00
+```
+
+### Install Hugo from Tarball
+
+#### Step 1: Decide on the location
+
+When installing from the tarball, you have to decide if you're going to install the binary in `/usr/local/bin` or in your home directory. There are three camps on this:
+
+1. Install it in `/usr/local/bin` so that all the users on your system have access to it. This is a good idea because it's a fairly standard place for executables. The downside is that you may need elevated privileges to put software into that location. Also, if there are multiple users on your system, they will all run the same version. Sometimes this can be an issue if you want to try out a new release.
+
+2. Install it in `~/bin` so that only you can execute it. This is a good idea because it's easy to do, easy to maintain, and doesn't require elevated privileges. The downside is that only you can run Hugo. If there are other users on your site, they have to maintain their own copies. That can lead to people running different versions. Of course, this does make it easier for you to experiment with different releases.
+
+3. Install it in your `Sites` directory. This is not a bad idea if you have only one site that you're building. It keeps every thing in a single place. If you want to try out new releases, you can make a copy of the entire site and update the Hugo executable.
+
+All three locations will work for you. In the interest of brevity, this guide focuses on option #2.
+
+#### Step 2: Download the Tarball
+
+1. Open <https://github.com/gohugoio/hugo/releases> in your browser.
+
+2. Find the current release by scrolling down and looking for the green tag that reads "Latest Release."
+
+3. Download the current tarball for the Mac. The name will be something like `hugo_X.Y_osx-64bit.tgz`, where `X.YY` is the release number.
+
+4. By default, the tarball will be saved to your `~/Downloads` directory. If you choose to use a different location, you'll need to change that in the following steps.
+
+#### Step 3: Confirm your download
+
+Verify that the tarball wasn't corrupted during the download:
+
+```
+tar tvf ~/Downloads/hugo_X.Y_osx-64bit.tgz
+-rwxrwxrwx 0 0 0 0 Feb 22 04:02 hugo_X.Y_osx-64bit/hugo_X.Y_osx-64bit.tgz
+-rwxrwxrwx 0 0 0 0 Feb 22 03:24 hugo_X.Y_osx-64bit/README.md
+-rwxrwxrwx 0 0 0 0 Jan 30 18:48 hugo_X.Y_osx-64bit/LICENSE.md
+```
+
+The `.md` files are documentation for Hugo. The other file is the executable.
+
+#### Step 4: Install Into Your `bin` Directory
+
+```
+# create the directory if needed
+mkdir -p ~/bin
+
+# make it the working directory
+cd ~/bin
+
+# extract the tarball
+tar -xvzf ~/Downloads/hugo_X.Y_osx-64bit.tgz
+Archive: hugo_X.Y_osx-64bit.tgz
+ x ./
+ x ./hugo
+ x ./LICENSE.md
+ x ./README.md
+
+# verify that it runs
+./hugo version
+Hugo Static Site Generator v0.13 BuildDate: 2015-02-22T04:02:30-06:00
+```
+
+You may need to add your bin directory to your `PATH` variable. The `which` command will check for us. If it can find `hugo`, it will print the full path to it. Otherwise, it will not print anything.
+
+```
+# check if hugo is in the path
+which hugo
+/Users/USERNAME/bin/hugo
+```
+
+If `hugo` is not in your `PATH`, add it by updating your `~/.bash_profile` file. First, start up an editor:
+
+```
+nano ~/.bash_profile
+```
+
+Add a line to update your `PATH` variable:
+
+```
+export PATH=$PATH:$HOME/bin
+```
+
+Then save the file by pressing Control-X, then Y to save the file and return to the prompt.
+
+Close the terminal and open a new terminal to pick up the changes to your profile. Verify your success by running the `which hugo` command again.
+
+You've successfully installed Hugo.
+
+### Build from Source on Mac
+
+If you want to compile Hugo yourself, you'll need to install Go (aka Golang). You can [install Go directly from the Go website](https://golang.org/dl/) or via Homebrew using the following command:
+
+```
+brew install go
+```
+
+#### Step 1: Get the Source
+
+If you want to compile a specific version of Hugo, go to <https://github.com/gohugoio/hugo/releases> and download the source code for the version of your choice. If you want to compile Hugo with all the latest changes (which might include bugs), clone the Hugo repository:
+
+```
+git clone https://github.com/gohugoio/hugo
+```
+
+{{% warning "Sometimes \"Latest\" = \"Bugs\""%}}
+Cloning the Hugo repository directly means taking the good with the bad. By using the bleeding-edge version of Hugo, you make your development susceptible to the latest features, as well as the latest bugs. Your feedback is appreciated. If you find a bug in the latest release, [please create an issue on GitHub](https://github.com/gohugoio/hugo/issues/new).
+{{% /warning %}}
+
+#### Step 2: Compiling
+
+Make the directory containing the source your working directory and then fetch Hugo's dependencies:
+
+```
+mkdir -p src/github.com/gohugoio
+ln -sf $(pwd) src/github.com/gohugoio/hugo
+
+# set the build path for Go
+export GOPATH=$(pwd)
+
+go get
+```
+
+This will fetch the absolute latest version of the dependencies. If Hugo fails to build, it may be the result of a dependency's author introducing a breaking change.
+
+Once you have properly configured your directory, you can compile Hugo using the following command:
+
+```
+go build -o hugo main.go
+```
+
+Then place the `hugo` executable somewhere in your `$PATH`. You're now ready to start using Hugo.
+
+## Windows
+
+The following aims to be a complete guide to installing Hugo on your Windows PC.
+
+{{< youtube G7umPCU-8xc >}}
+
+### Assumptions
+
+1. You will use `C:\Hugo\Sites` as the starting point for your new project.
+2. You will use `C:\Hugo\bin` to store executable files.
+
+### Set up Your Directories
+
+You'll need a place to store the Hugo executable, your [content][], and the generated Hugo website:
+
+1. Open Windows Explorer.
+2. Create a new folder: `C:\Hugo`, assuming you want Hugo on your C drive, although this can go anywhere
+3. Create a subfolder in the Hugo folder: `C:\Hugo\bin`
+4. Create another subfolder in Hugo: `C:\Hugo\Sites`
+
+### Technical Users
+
+1. Download the latest zipped Hugo executable from [Hugo Releases][releases].
+2. Extract all contents to your `..\Hugo\bin` folder.
+3. The `hugo` executable will be named as `hugo_hugo-version_platform_arch.exe`. Rename the executable to `hugo.exe` for ease of use.
+4. In PowerShell or your preferred CLI, add the `hugo.exe` executable to your PATH by navigating to `C:\Hugo\bin` (or the location of your hugo.exe file) and use the command `set PATH=%PATH%;C:\Hugo\bin`. If the `hugo` command does not work after a reboot, you may have to run the command prompt as administrator.
+
+### Less-technical Users
+
+1. Go to the [Hugo Releases][releases] page.
+2. The latest release is announced on top. Scroll to the bottom of the release announcement to see the downloads. They're all ZIP files.
+3. Find the Windows files near the bottom (they're in alphabetical order, so Windows is last) – download either the 32-bit or 64-bit file depending on whether you have 32-bit or 64-bit Windows. (If you don't know, [see here](https://esupport.trendmicro.com/en-us/home/pages/technical-support/1038680.aspx).)
+4. Move the ZIP file into your `C:\Hugo\bin` folder.
+5. Double-click on the ZIP file and extract its contents. Be sure to extract the contents into the same `C:\Hugo\bin` folder – Windows will do this by default unless you tell it to extract somewhere else.
++6. You should now have three new files: The hugo executable (`hugo.exe`), `LICENSE`, and `README.md`.
+
+Now you need to add Hugo to your Windows PATH settings:
+
+#### For Windows 10 Users:
+
+* Right click on the **Start** button.
+* Click on **System**.
+* Click on **Advanced System Settings** on the left.
+* Click on the **Environment Variables...** button on the bottom.
+* In the User variables section, find the row that starts with PATH (PATH will be all caps).
+* Double-click on **PATH**.
+* Click the **New...** button.
+* Type in the folder where `hugo.exe` was extracted, which is `C:\Hugo\bin` if you went by the instructions above. *The PATH entry should be the folder where Hugo lives and not the binary.* Press <kbd>Enter</kbd> when you're done typing.
+* Click OK at every window to exit.
+
+{{% note "Path Editor in Windows 10"%}}
+The path editor in Windows 10 was added in the large [November 2015 Update](https://blogs.windows.com/windowsexperience/2015/11/12/first-major-update-for-windows-10-available-today/). You'll need to have that or a later update installed for the above steps to work. You can see what Windows 10 build you have by clicking on the <i class="fa fa-windows"></i> Start button → Settings → System → About. See [here](https://www.howtogeek.com/236195/how-to-find-out-which-build-and-version-of-windows-10-you-have/) for more.)
+{{% /note %}}
+
+#### For Windows 7 and 8.x users:
+
+Windows 7 and 8.1 do not include the easy path editor included in Windows 10, so non-technical users on those platforms are advised to install a free third-party path editor like [Windows Environment Variables Editor][Windows Environment Variables Editor] or [Path Editor](https://patheditor2.codeplex.com/).
+
+### Verify the Executable
+
+Run a few commands to verify that the executable is ready to run, and then build a sample site to get started.
+
+#### 1. Open a Command Prompt
+
+At the prompt, type `hugo help` and press the <kbd>Enter</kbd> key. You should see output that starts with:
+
+```
+hugo is the main command, used to build your Hugo site.
+
+Hugo is a Fast and Flexible Static Site Generator
+built with love by spf13 and friends in Go.
+
+Complete documentation is available at https://gohugo.io/.
+```
+
+If you do, then the installation is complete. If you don't, double-check the path that you placed the `hugo.exe` file in and that you typed that path correctly when you added it to your `PATH` variable. If you're still not getting the output, search the [Hugo discussion forum][forum] to see if others have already figured out our problem. If not, add a note---in the "Support" category---and be sure to include your command and the output.
+
+At the prompt, change your directory to the `Sites` directory.
+
+```
+C:\Program Files> cd C:\Hugo\Sites
+C:\Hugo\Sites>
+```
+
+#### 2. Run the Command
+
+Run the command to generate a new site. I'm using `example.com` as the name of the site.
+
+```
+C:\Hugo\Sites> hugo new site example.com
+```
+
+You should now have a directory at `C:\Hugo\Sites\example.com`. Change into that directory and list the contents. You should get output similar to the following:
+
+```
+C:\Hugo\Sites> cd example.com
+C:\Hugo\Sites\example.com> dir
+Directory of C:\hugo\sites\example.com
+
+04/13/2015 10:44 PM <DIR> .
+04/13/2015 10:44 PM <DIR> ..
+04/13/2015 10:44 PM <DIR> archetypes
+04/13/2015 10:44 PM 83 config.toml
+04/13/2015 10:44 PM <DIR> content
+04/13/2015 10:44 PM <DIR> data
+04/13/2015 10:44 PM <DIR> layouts
+04/13/2015 10:44 PM <DIR> static
+ 1 File(s) 83 bytes
+ 7 Dir(s) 6,273,331,200 bytes free
+```
+
+### Troubleshoot Windows Installation
+
+[@dhersam][] has created a nice video on common issues:
+
+{{< youtube c8fJIRNChmU >}}
+
+## Linux
+
+### Snap Package
+
+In any of the [Linux distributions that support snaps][snaps], you may install install the "extended" Sass/SCSS version with this command:
+
+ snap install hugo --channel=extended
+
+To install the non-extended version without Sass/SCSS support:
+
+ snap install hugo
+
+To switch between the two, use either `snap refresh hugo --channel=extended` or `snap refresh hugo --channel=stable`.
+
+{{% note %}}
+Hugo-as-a-snap can write only inside the user’s `$HOME` directory---and gvfs-mounted directories owned by the user---because of Snaps’ confinement and security model. More information is also available [in this related GitHub issue](https://github.com/gohugoio/hugo/issues/3143). Use ```sudo snap install hugo --classic``` to disable the default security model if you want hugo to be able to have write access in other paths besides the user’s `$HOME` directory.
+{{% /note %}}
+
+### Debian and Ubuntu
+
+[@anthonyfok](https://github.com/anthonyfok) and friends in the [Debian Go Packaging Team](https://go-team.pages.debian.net/) maintains an official hugo [Debian package](https://packages.debian.org/hugo) which is shared with [Ubuntu](https://packages.ubuntu.com/hugo) and is installable via `apt-get`:
+
+ sudo apt-get install hugo
+
+This installs the "extended" Sass/SCSS version.
+
+### Arch Linux
+
+You can also install Hugo from the Arch Linux [community](https://www.archlinux.org/packages/community/x86_64/hugo/) repository. Applies also to derivatives such as Manjaro.
+
+```
+sudo pacman -Syu hugo
+```
+
+### Fedora, Red Hat and CentOS
+
+Fedora maintains an [official package for Hugo](https://apps.fedoraproject.org/packages/hugo) which may be installed with:
+
+ sudo dnf install hugo
+
+For the latest version, the Hugo package maintained by [@daftaupe](https://github.com/daftaupe) at Fedora Copr is recommended:
+
+* <https://copr.fedorainfracloud.org/coprs/daftaupe/hugo/>
+
+See the [related discussion in the Hugo forums][redhatforum].
+
++### Solus
++
++Solus includes Hugo in its package repository, it may be installed with:
++
++```
++sudo eopkg install hugo
++```
++
+## OpenBSD
+
+OpenBSD provides a package for Hugo via `pkg_add`:
+
+ doas pkg_add hugo
+
+
+## Upgrade Hugo
+
+Upgrading Hugo is as easy as downloading and replacing the executable you’ve placed in your `PATH` or run `brew upgrade hugo` if using Homebrew.
+
+## Install Pygments (Optional)
+
+The Hugo executable has one *optional* external dependency for source code highlighting ([Pygments][pygments]).
+
+If you want to have source code highlighting using the [highlight shortcode][], you need to install the Python-based Pygments program. The procedure is outlined on the [Pygments homepage][pygments].
+
+## Next Steps
+
+Now that you've installed Hugo, read the [Quick Start guide][quickstart] and explore the rest of the documentation. If you have questions, ask the Hugo community directly by visiting the [Hugo Discussion Forum][forum].
+
+[brew]: https://brew.sh/
+[Chocolatey]: https://chocolatey.org/
+[content]: /content-management/
+[@dhersam]: https://github.com/dhersam
+[forum]: https://discourse.gohugo.io
+[mage]: https://github.com/magefile/mage
+[dep]: https://github.com/golang/dep
+[highlight shortcode]: /content-management/shortcodes/#highlight
+[installgit]: http://git-scm.com/
+[installgo]: https://golang.org/dl/
+[Path Editor]: https://patheditor2.codeplex.com/
+[pygments]: http://pygments.org
+[quickstart]: /getting-started/quick-start/
+[redhatforum]: https://discourse.gohugo.io/t/solved-fedora-copr-repository-out-of-service/2491
+[releases]: https://github.com/gohugoio/hugo/releases
+[Scoop]: https://scoop.sh/
+[snaps]: http://snapcraft.io/docs/core/install
+[windowsarch]: https://esupport.trendmicro.com/en-us/home/pages/technical-support/1038680.aspx
+[Windows Environment Variables Editor]: http://eveditor.com/
--- /dev/null
- * You have completed the [Quick Start][] or have Hugo website you are ready to deploy and share with the world.
+---
+title: Host on Netlify
+linktitle: Host on Netlify
+description: Netlify can host your Hugo site with CDN, continuous deployment, 1-click HTTPS, an admin GUI, and its own CLI.
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-03-11
+categories: [hosting and deployment]
+keywords: [netlify,hosting,deployment]
+authors: [Ryan Watters, Seth MacLeod]
+menu:
+ docs:
+ parent: "hosting-and-deployment"
+ weight: 10
+weight: 10
+sections_weight: 10
+draft: false
+aliases: []
+toc: true
+---
+
+[Netlify][netlify] provides continuous deployment services, global CDN, ultra-fast DNS, atomic deploys, instant cache invalidation, one-click SSL, a browser-based interface, a CLI, and many other features for managing your Hugo website.
+
+## Assumptions
+
+* You have an account with GitHub, GitLab, or Bitbucket.
- ## Configure Hugo Version in Netlify
++* You have completed the [Quick Start][] or have a Hugo website you are ready to deploy and share with the world.
+* You do not already have a Netlify account.
+
+## Create a Netlify account
+
+Go to [app.netlify.com][] and select your preferred signup method. This will likely be a hosted Git provider, although you also have the option to sign up with an email address.
+
+The following examples use GitHub, but other git providers will follow a similar process.
+
+
+
+Selecting GitHub will bring up an authorization modal for authentication. Select "Authorize application."
+
+
+
+## Create a New Site with Continuous Deployment
+
+You're now already a Netlify member and should be brought to your new dashboard. Select "New site from git."
+
+
+
+Netlify will then start walking you through the steps necessary for continuous deployment. First, you'll need to select your git provider again, but this time you are giving Netlify added permissions to your repositories.
+
+
+
+And then again with the GitHub authorization modal:
+
+
+
+Select the repo you want to use for continuous deployment. If you have a large number of repositories, you can filter through them in real time using repo search:
+
+
+
+Once selected, you'll be brought to a screen for basic setup. Here you can select the branch you wanted published, your [build command][], and your publish (i.e. deploy) directory. The publish directory should mirror that of what you've set in your [site configuration][config], the default of which is `public`. The following steps assume you are publishing from the `master` branch.
+
- {{< readfile file="netlify.toml" highlight="toml" >}}
++## Configure Hugo Version in Netlify
+
+You can [set Hugo version](https://www.netlify.com/blog/2017/04/11/netlify-plus-hugo-0.20-and-beyond/) for your environments in `netlify.toml` file or set `HUGO_VERSION` as a build environment variable in the Netlify console.
+
+For production:
+
+```
+[context.production.environment]
+ HUGO_VERSION = "0.36"
+```
+
+For testing:
+
+```
+[context.deploy-preview.environment]
+ HUGO_VERSION = "0.36"
+```
+
+The Netlify configuration file can be a little hard to understand and get right for the different environment, and you may get some inspiration and tips from this site's `netlify.toml`:
+
+{{< code file="netlify.toml" nocode="true" >}}
++{{< readfile file="netlify.toml" highlight="toml" >}}
+{{< /code >}}
+
+## Build and Deploy Site
+
+In the Netlify console, selecting "Deploy site" will immediately take you to a terminal for your build:.
+
+
+
+Once the build is finished---this should only take a few seconds--you should now see a "Hero Card" at the top of your screen letting you know the deployment is successful. The Hero Card is the first element that you see in most pages. It allows you to see a quick summary of the page and gives access to the most common/pertinent actions and information. You'll see that the URL is automatically generated by Netlify. You can update the URL in "Settings."
+
+
+
+
+
+[Visit the live site][visit].
+
+Now every time you push changes to your hosted git repository, Netlify will rebuild and redeploy your site.
+
+See [this blog post](https://www.netlify.com/blog/2017/04/11/netlify-plus-hugo-0.20-and-beyond/) for more details about how Netlify handles Hugo versions.
+
+## Use Hugo Themes with Netlify
+
+The [`git clone` method for installing themes][installthemes] is not supported by Netlify. If you were to use `git clone`, it would require you to recursively remove the `.git` subdirectory from the theme folder and would therefore prevent compatibility with future versions of the theme.
+
+A *better* approach is to install a theme as a proper git submodule. You can [read the GitHub documentation for submodules][ghsm] or those found on [Git's website][gitsm] for more information, but the command is similar to that of `git clone`:
+
+```
+cd themes
+git submodule add https://github.com/<THEMECREATOR>/<THEMENAME>
+```
+
+It is recommended to only use stable versions of a theme (if it’s versioned) and always check the changelog. This can be done by checking out a specific release within the theme's directory.
+
+Switch to the theme's directory and list all available versions:
+
+```
+cd themes/<theme>
+git tag
+# exit with q
+```
+
+You can checkout a specific version as follows:
+
+```
+git checkout tags/<version-name>
+```
+
+## Next Steps
+
+You now have a live website served over https, distributed through CDN, and configured for continuous deployment. Dig deeper into the Netlify documentation:
+
+1. [Using a Custom Domain][]
+2. [Setting up HTTPS on Custom Domains][httpscustom]
+3. [Redirects and Rewrite Rules][]
+
+
+[app.netlify.com]: https://app.netlify.com
+[build command]: /getting-started/usage/#the-hugo-command
+[config]: /getting-started/configuration/
+[ghsm]: https://github.com/blog/2104-working-with-submodules
+[gitsm]: https://git-scm.com/book/en/v2/Git-Tools-Submodules
+[httpscustom]: https://www.netlify.com/docs/ssl/
+[hugoversions]: https://github.com/netlify/build-image/blob/master/Dockerfile#L216
+[installthemes]: /themes/installing/
+[netlify]: https://www.netlify.com/
+[netlifysignup]: https://app.netlify.com/signup
+[Quick Start]: /getting-started/quick-start/
+[Redirects and Rewrite Rules]: https://www.netlify.com/docs/redirects/
+[Using a Custom Domain]: https://www.netlify.com/docs/custom-domains/
+[visit]: https://hugo-netlify-example.netlify.com
--- /dev/null
- Hugo Pipe's PostCSS requires `postcss-cli` javascript package to be installed on the environement along with any PostCSS plugin used.
+---
+title: PostCSS
+description: Hugo Pipes can process CSS files with PostCSS.
+date: 2018-07-14
+publishdate: 2018-07-14
+lastmod: 2018-07-14
+categories: [asset management]
+keywords: []
+menu:
+ docs:
+ parent: "pipes"
+ weight: 40
+weight: 40
+sections_weight: 40
+draft: false
+---
+
+
+Any asset file can be processed using `resources.PostCSS` which takes for argument the resource object and a slice of options listed below.
+
+The resource will be processed using the project's or theme's own `postcss.config.js` or any file set with the `config` option.
+
+
+```go-html-template
+{{ $css := resources.Get "css/main.css" }}
+{{ $style := $css | resources.PostCSS }}
+```
+
+{{% note %}}
++Hugo Pipe's PostCSS requires the `postcss-cli` JavaScript package to be installed in the environment (`npm install -g postcss-cli`) along with any PostCSS plugin(s) used (e.g., `npm install -g autoprefixer`).
++
++If you are using the Hugo Snap package, PostCSS and plugin(s) need to be installed locally within your Hugo site directory, e.g., `npm install postcss-cli` without the `-g` flag.
+{{% /note %}}
+### Options
+
+config [string]
+: Path to the PostCSS configuration file
+
+noMap [bool]
+: Default is `true`. Disable the default inline sourcemaps
+
+_If no configuration file is used:_
+
+use [string]
+: List of PostCSS plugins to use
+
+parser [string]
+: Custom PostCSS parser
+
+stringifier [string]
+: Custom PostCSS stringifier
+
+syntax [string]
+: Custom postcss syntax
+
+```go-html-template
+{{ $style := resources.Get "css/main.css" | resources.PostCSS (dict "config" "customPostCSS.js" "noMap" true) }}
+```
--- /dev/null
+---
+title: SASS / SCSS
+description: Hugo Pipes allows the processing of SASS and SCSS files.
+date: 2018-07-14
+publishdate: 2018-07-14
+lastmod: 2018-07-14
+categories: [asset management]
+keywords: []
+menu:
+ docs:
+ parent: "pipes"
+ weight: 30
+weight: 02
+sections_weight: 02
+draft: false
+---
+
+
+Any SASS or SCSS file can be transformed into a CSS file using `resources.ToCSS` which takes two arguments, the resource object and a map of options listed below.
+
+```go-html-template
+{{ $sass := resources.Get "sass/main.scss" }}
+{{ $style := $sass | resources.ToCSS }}
+```
+
+### Options
+targetPath [string]
+: If not set, the resource's target path will be the asset file original path with its extension replaced by `.css`.
+
+outputStyle [string]
+: Default is `nested`. Other available output styles are `expanded`, `compact` and `compressed`.
+
+precision [int]
+: Precision of floating point math.
+
+enableSourceMap [bool]
+: When enabled, a source map will be generated.
+
+includePaths [string slice]
+: Additional SCSS/SASS include paths. Paths must be relative to the project directory.
+
+```go-html-template
+{{ $options := (dict "targetPath" "style.css" "outputStyle" "compressed" "enableSourceMap" true "includePaths" (slice "node_modules/myscss")) }}
+{{ $style := resources.Get "sass/main.scss" | resources.ToCSS $options }}
+```
++
++{{% note %}}
++Setting `outputStyle` to `compressed` will handle SASS/SCSS files minification better than the more generic [`resources.Minify`]({{< ref "minification">}}).
++{{% /note %}}
--- /dev/null
- title: "0.47"
- description: "0.47"
+
+---
+date: 2018-08-17
- Hugo `0.47` is named **Hugo Reloaded**. It adds minification support for the final rendered output (run `hugo --minify`), but it is mostly a bug fix release. And most notably, it fixes a set of issues with live-reloading/partial rebuilds when running `hugo server`. Working with bundles should now be a more pleasant experience, to pick one example.
++title: "Output Minification, Live-Reload Fixes and More"
++description: "Hugo 0.47: Adds minification of rendered output, but is mostly a massive bug fix release."
+categories: ["Releases"]
+---
+
++Hugo `0.47` is named **Hugo Reloaded**. It adds minification support for the final rendered output (run `hugo --minify`), but it is mostly a bug fix release. And most notably, it fixes a set of issues with live-reloading/partial rebuilds when running `hugo server`. Working with bundles should now be a more pleasant experience, to pick one example.
+
+This release represents **35 contributions by 6 contributors** to the main Hugo code base.
+[@bep](https://github.com/bep) leads the Hugo development with a significant amount of contributions, but also a big shoutout to [@satotake](https://github.com/satotake), [@anthonyfok](https://github.com/anthonyfok), and [@coliff](https://github.com/coliff) for their ongoing contributions.
+
+And a big thanks to [@digitalcraftsman](https://github.com/digitalcraftsman) and [@onedrawingperday](https://github.com/onedrawingperday) for their relentless work on keeping the themes site in pristine condition and to [@kaushalmodi](https://github.com/kaushalmodi) for his great work on the documentation site.
+
+Many have also been busy writing and fixing the documentation in [hugoDocs](https://github.com/gohugoio/hugoDocs),
+which has received **21 contributions by 10 contributors**. A special thanks to [@bep](https://github.com/bep), [@aapeliv](https://github.com/aapeliv), [@regisphilibert](https://github.com/regisphilibert), and [@brentybh](https://github.com/brentybh) for their work on the documentation site.
+
+
+Hugo now has:
+
+* 27980+ [stars](https://github.com/gohugoio/hugo/stargazers)
+* 442+ [contributors](https://github.com/gohugoio/hugo/graphs/contributors)
+* 251+ [themes](http://themes.gohugo.io/)
+
+## Enhancements
+
+### Templates
+
+* Suppress blank lines from opengraph internal template [c09ee78f](https://github.com/gohugoio/hugo/commit/c09ee78fd235599d3fb794110cd75c024d80cfca) [@anthonyfok](https://github.com/anthonyfok)
+* Add MIME type to embedded JS [755d1ffe](https://github.com/gohugoio/hugo/commit/755d1ffe7a22d8ad83485240ff78cf25d501602f) [@bep](https://github.com/bep) [#5042](https://github.com/gohugoio/hugo/issues/5042)
+* Add `os.Stat` template function [d7112085](https://github.com/gohugoio/hugo/commit/d71120852a8e14d0ea4d24de269fce041ef7b666) [@satotake](https://github.com/satotake)
+
+### Output
+
+* Add support for minification of final output [789ef8c6](https://github.com/gohugoio/hugo/commit/789ef8c639e4621abd36da530bcb5942ac9297da) [@bep](https://github.com/bep) [#1251](https://github.com/gohugoio/hugo/issues/1251)
+
+### Other
+
+* Regenerate CLI docs [4a16b5f4](https://github.com/gohugoio/hugo/commit/4a16b5f4b0adbb31fee611c378de9d5526de2f86) [@bep](https://github.com/bep)
+* Include theme name in version mismatch error [e5052f4e](https://github.com/gohugoio/hugo/commit/e5052f4e09b6df590cddf2f8bc2c834fd3af3082) [@bep](https://github.com/bep) [#5044](https://github.com/gohugoio/hugo/issues/5044)
+* Make the JS minifier matcher less specific [c81fbf46](https://github.com/gohugoio/hugo/commit/c81fbf4625ae7cc7dd3a7a526331ddfdf5237cc6) [@bep](https://github.com/bep) [#5073](https://github.com/gohugoio/hugo/issues/5073)
+* Close file when done [f6ae436c](https://github.com/gohugoio/hugo/commit/f6ae436c5878bafeafa0bb2646a2c9b32c9b4380) [@bep](https://github.com/bep) [#5062](https://github.com/gohugoio/hugo/issues/5062)
+* https links to 3rd party sites [c2a67413](https://github.com/gohugoio/hugo/commit/c2a6741394bc609a663522b245d3d75f0ad17da4) [@coliff](https://github.com/coliff)
+* Update alias.go [06bd0136](https://github.com/gohugoio/hugo/commit/06bd0136419ebd6727635716c7023494cc5a8257) [@coliff](https://github.com/coliff)
+* Remove test debug [fb3cb05c](https://github.com/gohugoio/hugo/commit/fb3cb05cc3dfc50370449f622fb0130ba7e0ced2) [@bep](https://github.com/bep)
+* Update dependencies [d07882df](https://github.com/gohugoio/hugo/commit/d07882dfb76a65cce79aaa6f27df71279cd30600) [@bep](https://github.com/bep)
+* Update Chroma [7f535671](https://github.com/gohugoio/hugo/commit/7f5356717d14079432365974e1424fc4ff5987c9) [@bep](https://github.com/bep) [#5025](https://github.com/gohugoio/hugo/issues/5025)
+* Remove alias of os.Stat [71931b30](https://github.com/gohugoio/hugo/commit/71931b30b1813b146aaa60f5cdab16c0f9ebebdb) [@satotake](https://github.com/satotake)
+* Renmae FileStat Stat [d40116e5](https://github.com/gohugoio/hugo/commit/d40116e5f941e4734ed3bed69dce8ffe11fc76b2) [@satotake](https://github.com/satotake)
+* Reduce allocation in the benchmark itself [a6b1eb1e](https://github.com/gohugoio/hugo/commit/a6b1eb1e9150aa5c1c86fe7424cc4167d6f59a5a) [@bep](https://github.com/bep)
+* Simplify the 0 transformer case [27110133](https://github.com/gohugoio/hugo/commit/27110133ffca05feae2e11a9ff28a9a00f613350) [@bep](https://github.com/bep)
+
+## Fixes
+
+### Templates
+
+* Fix compiling Amber templates that import other templates [37438757](https://github.com/gohugoio/hugo/commit/37438757788d279c839506d54f460b2ab37db164) [@Stebalien](https://github.com/Stebalien)
+* Reimplement the ".Params tolower" template transformer [5c538491](https://github.com/gohugoio/hugo/commit/5c5384916e8f954f3ea66148ecceb3732584588e) [@bep](https://github.com/bep) [#5068](https://github.com/gohugoio/hugo/issues/5068)
+
+### Output
+
+* Fix Resource output in multihost setups [78f8475a](https://github.com/gohugoio/hugo/commit/78f8475a054a6277d37f13329afd240b00dc9408) [@bep](https://github.com/bep) [#5058](https://github.com/gohugoio/hugo/issues/5058)
+
+### Core
+
+* Force render of any changed page, even in Fast Render Mode [22475460](https://github.com/gohugoio/hugo/commit/2247546017c00201d2ce1232dd5303295451f1cc) [@bep](https://github.com/bep) [#5083](https://github.com/gohugoio/hugo/issues/5083)
+* Add configFile(s) back to the watch list after REMOVE event [abc54080](https://github.com/gohugoio/hugo/commit/abc54080ec8c43e8989c081d934b59f0c9570c0b) [@anthonyfok](https://github.com/anthonyfok) [#4701](https://github.com/gohugoio/hugo/issues/4701)
+* Gracefully handle typos in server config when running the server [a655e00d](https://github.com/gohugoio/hugo/commit/a655e00d702dbc20b3961b131b33ab21841b043d) [@bep](https://github.com/bep) [#5081](https://github.com/gohugoio/hugo/issues/5081)
+* Fix shortcode output wrapped in p [78c99463](https://github.com/gohugoio/hugo/commit/78c99463fdd45c91af9933528d12d36a86dc6482) [@gllera](https://github.com/gllera) [#1642](https://github.com/gohugoio/hugo/issues/1642)
+* Adjust tests for shortcode p-issue [baa62d0a](https://github.com/gohugoio/hugo/commit/baa62d0abbbf24a17d0aa800a4bb217f026c49ad) [@bep](https://github.com/bep) [#1642](https://github.com/gohugoio/hugo/issues/1642)
+* Fix image cache-clearing for sub-languages [9d973004](https://github.com/gohugoio/hugo/commit/9d973004f5379cff2adda489566fe40683553c4c) [@bep](https://github.com/bep) [#5084](https://github.com/gohugoio/hugo/issues/5084)
+* Fix error when deleting a bundle in server mode [0a88741f](https://github.com/gohugoio/hugo/commit/0a88741fe85f4f7aedc02ed748dfeb8ccc073dbf) [@bep](https://github.com/bep) [#5077](https://github.com/gohugoio/hugo/issues/5077)
+* Fix Related when called from shortcode [0dd06bda](https://github.com/gohugoio/hugo/commit/0dd06bdac008aa81ec2e8f29ad8110dac0227011) [@bep](https://github.com/bep) [#5071](https://github.com/gohugoio/hugo/issues/5071)
+* Use the interface value when doing Related search [a6f199f7](https://github.com/gohugoio/hugo/commit/a6f199f7a640161333608b4a843d701f7e182829) [@bep](https://github.com/bep) [#5071](https://github.com/gohugoio/hugo/issues/5071)
+* Fix GitInfo when multiple content dirs [2182ecfd](https://github.com/gohugoio/hugo/commit/2182ecfd34a24521bf0e3c939627a55327eb1e19) [@bep](https://github.com/bep) [#5054](https://github.com/gohugoio/hugo/issues/5054)
+* Add multiple content dirs to GitInfo test site [e85833d8](https://github.com/gohugoio/hugo/commit/e85833d868a902840c5ed1c90713256153b2548b) [@bep](https://github.com/bep) [#5054](https://github.com/gohugoio/hugo/issues/5054)
+* Fix "adding a bundle" in server mode [d139a037](https://github.com/gohugoio/hugo/commit/d139a037d98e4b388687eecb7831758412247c58) [@bep](https://github.com/bep) [#5075](https://github.com/gohugoio/hugo/issues/5075)
+* Fix typo [c362634b](https://github.com/gohugoio/hugo/commit/c362634b7d8802ea81b0b4341c800a9f78f7cd7c) [@satotake](https://github.com/satotake)
--- /dev/null
- title: "0.47.1"
- description: "0.47.1"
+
+---
+date: 2018-08-20
++title: "Two Bug Fixes"
++description: "Hugo 0.47.1: Two Bug Fixes"
+categories: ["Releases"]
+images:
+- images/blog/hugo-bug-poster.png
+
+---
+
+ This is a bug-fix release with two fixes.
+
+# Fixes
+
+* Fix .Site.Params case regression [fdff0d3a](https://github.com/gohugoio/hugo/commit/fdff0d3af4670f7079e539fef4b92af2a866d02d) [@bep](https://github.com/bep) [#5094](https://github.com/gohugoio/hugo/issues/5094)
+* Do not strip IE conditional statements [5a0ee2b9](https://github.com/gohugoio/hugo/commit/5a0ee2b934e38d596da0f9742361f81c1221e3d5) [@bep](https://github.com/bep) [#5089](https://github.com/gohugoio/hugo/issues/5089)
+
+## Updates to Linux Snap build
+
+* Remove unused files from Git, Perl, etc. [834617f9](https://github.com/gohugoio/hugo/commit/834617f9f8d870643b2631fe607471c8e2ef2f47) [@anthonyfok](https://github.com/anthonyfok)
+* Add nodejs to allow PostCSS to work [ef20ec1f](https://github.com/gohugoio/hugo/commit/ef20ec1fbaa8f5841b3fbe18978d4d8c19d8fc53) [@anthonyfok](https://github.com/anthonyfok)
+
+
+
+
+
+
+
+
--- /dev/null
- title: "0.48"
- description: "0.48"
+
+---
+date: 2018-08-29
- Hugo `0.48` is built with the brand new Go 1.11. On the technical side this means that Hugo now uses [Go Modules](https://github.com/golang/go/wiki/Modules) for the build. The big new functional thing in Go 1.11 for Hugo is added support for [variable overwrites](https://github.com/golang/go/issues/10608). This means that you can now do:
++title: "This One Goes to 11!"
++description: "With Go 1.11, Hugo finally gets support for variable overwrites in templates!"
+categories: ["Releases"]
+---
+
- ```
++Hugo `0.48` is built with the brand new Go 1.11. On the technical side this means that Hugo now uses [Go Modules](https://github.com/golang/go/wiki/Modules) for the build. The big new functional thing in Go 1.11 for Hugo is added support for [variable overwrites](https://github.com/golang/go/issues/10608). This means that you can now do this and get the expected result:
+
- {{ $var = "Hugo Home" }}
++```go-html-template
+{{ $var := "Hugo Page" }}
+{{ if .IsHome }}
++ {{ $var = "Hugo Home" }}
+{{ end }}
+Var is {{ $var }}
+```
+
+The above may look obvious, but has not been possible until now. In Hugo we have had `.Scratch` as a workaround for this, but Go 1.11 will help clean up a lot of templates.
+
+This release represents **23 contributions by 5 contributors** to the main Hugo code base. [@bep](https://github.com/bep) leads the Hugo development with a significant amount of contributions, but also a big shoutout to [@anthonyfok](https://github.com/anthonyfok), [@vsopvsop](https://github.com/vsopvsop), and [@moorereason](https://github.com/moorereason) for their ongoing contributions. And a big thanks to [@digitalcraftsman](https://github.com/digitalcraftsman) for his relentless work on keeping the themes site in pristine condition and to [@kaushalmodi](https://github.com/kaushalmodi) for his great work on the documentation site.
+
+Many have also been busy writing and fixing the documentation in [hugoDocs](https://github.com/gohugoio/hugoDocs),
+which has received **15 contributions by 12 contributors**. A special thanks to [@bep](https://github.com/bep), [@kaushalmodi](https://github.com/kaushalmodi), [@regisphilibert](https://github.com/regisphilibert), and [@anthonyfok](https://github.com/anthonyfok) for their work on the documentation site.
+
+
+Hugo now has:
+
+* 28275+ [stars](https://github.com/gohugoio/hugo/stargazers)
+* 441+ [contributors](https://github.com/gohugoio/hugo/graphs/contributors)
+* 252+ [themes](http://themes.gohugo.io/)
+
+## Enhancements
+
+* Add a test for template variable overwrite [0c8a4154](https://github.com/gohugoio/hugo/commit/0c8a4154838e32a33d34202fd4fa0187aa502190) [@bep](https://github.com/bep)
+* Include language code in REF_NOT_FOUND errors [94d0e79d](https://github.com/gohugoio/hugo/commit/94d0e79d33994b9a9d26a4d020500acdcc71e58c) [@bep](https://github.com/bep) [#5110](https://github.com/gohugoio/hugo/issues/5110)
+* Improve minifier MIME type resolution [ebb56e8b](https://github.com/gohugoio/hugo/commit/ebb56e8bdbfaf4f955326017e40b2805850871e9) [@bep](https://github.com/bep) [#5093](https://github.com/gohugoio/hugo/issues/5093)
+* Update to Go 1.11 [6b9934a2](https://github.com/gohugoio/hugo/commit/6b9934a26615ea614b1774770532cae9762a58d3) [@bep](https://github.com/bep) [#5115](https://github.com/gohugoio/hugo/issues/5115)
+* Set GO111MODULE=on for mage install [c7f05779](https://github.com/gohugoio/hugo/commit/c7f057797ca7bfc781d5a2bbf181bb52360f160f) [@bep](https://github.com/bep) [#5115](https://github.com/gohugoio/hugo/issues/5115)
+* Add instruction to install PostCSS when missing [08d14113](https://github.com/gohugoio/hugo/commit/08d14113b60ff70ffe922e8098e289b099a70e0f) [@anthonyfok](https://github.com/anthonyfok) [#5111](https://github.com/gohugoio/hugo/issues/5111)
+* Update snapcraft build config to Go 1.11 [94d6d678](https://github.com/gohugoio/hugo/commit/94d6d6780fac78e9ed5ed58ecdb9821ad8f0f27c) [@bep](https://github.com/bep) [#5115](https://github.com/gohugoio/hugo/issues/5115)
+* Use Go 1.11 modules with Mage [45c9c45d](https://github.com/gohugoio/hugo/commit/45c9c45d1d0d99443fa6bb524a1265fa9ba95e0e) [@bep](https://github.com/bep) [#5115](https://github.com/gohugoio/hugo/issues/5115)
+* Add go.mod [fce32c07](https://github.com/gohugoio/hugo/commit/fce32c07fb80e9929bc2660cf1e681e93009d24b) [@bep](https://github.com/bep) [#5115](https://github.com/gohugoio/hugo/issues/5115)
+* Update Travis to Go 1.11 and Go 1.10.4 [d32ff16f](https://github.com/gohugoio/hugo/commit/d32ff16fd61f55874e81d73759afa099b8bdcb57) [@bep](https://github.com/bep) [#5115](https://github.com/gohugoio/hugo/issues/5115)
+* Skip installing postcss due to failure on build server [66f688f7](https://github.com/gohugoio/hugo/commit/66f688f7120560ca787c1a23e3e7fbc3aa617956) [@anthonyfok](https://github.com/anthonyfok)
+
+## Fixes
+
+* Keep end tags [e6eda2a3](https://github.com/gohugoio/hugo/commit/e6eda2a370aa1184e0afaf12e95dbd6f8b63ace5) [@vsopvsop](https://github.com/vsopvsop)
+* Fix permissions when creating new folders [f4675fa0](https://github.com/gohugoio/hugo/commit/f4675fa0f0fae2358adfaea49e8da824ee094495) [@bep](https://github.com/bep) [#5128](https://github.com/gohugoio/hugo/issues/5128)
+* Fix handling of taxonomy terms containing slashes [fff13253](https://github.com/gohugoio/hugo/commit/fff132537b4094221f4f099e2251f3cda613060f) [@moorereason](https://github.com/moorereason) [#4090](https://github.com/gohugoio/hugo/issues/4090)
+* Fix build on armv7 [8999de19](https://github.com/gohugoio/hugo/commit/8999de193c18b7aa07b44e5b7d9f443a8572e117) [@caarlos0](https://github.com/caarlos0) [#5101](https://github.com/gohugoio/hugo/issues/5101)
+
+
+
+
+
--- /dev/null
--- /dev/null
++The site is built by:
++
++* [Lauren Waller](https://twitter.com/waller_texas)
++* [Wayne Ashley Berry](https://twitter.com/waynethebrain)
++
--- /dev/null
--- /dev/null
++---
++title: Over
++date: 2018-09-12
++description: "Showcase: \"People from all disciplines contribute to our website; Hugo’s single static binary makes that possible.\""
++siteURL: https://madewithover.com/
++
++---
++
++At Over we're into creativity, and technology should not get in the way. We want it to be easy for everyone to create, and Hugo does the same for us. That's one of the reasons many of us are fond of using it.
++
++People from all disciplines contribute to our website, be it legal documentation, layout and design, recruiting, marketing and of course… engineering. Hugo allows us to do this with as little friction as possible. A lot of this comes down to Hugo being distributed as a single static binary. Copy, paste, run... and you're up and running!
++
++We use [Wercker](https://www.wercker.com/) for continuous integration and deployments, [GitHub](https://github.com/) for contributing to and writing markdown and [Firebase](https://firebase.google.com/docs/hosting/) for hosting.
++
++This infrastructure takes all the pressure off our engineers, anyone can contribute to our website. Anyone else can review the changes, and of course anyone with permission can deploy those approved changes as well!
++
++We're busy working on a few new features for our website, and Hugo continues to deliver above and beyond. We're so happy with the choice we made to use Hugo and to us it has become the de-facto static site generator.
--- /dev/null
+---
+title: Custom 404 Page
+linktitle: 404 Page
+description: If you know how to create a single page template, you have unlimited options for creating a custom 404.
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-03-31
+categories: [templates]
+keywords: [404, page not found]
+menu:
+ docs:
+ parent: "templates"
+ weight: 120
+weight: 120 #rem
+draft: false
+aliases: []
+toc: false
+---
+
+When using Hugo with [GitHub Pages](http://pages.github.com/), you can provide your own template for a [custom 404 error page](https://help.github.com/articles/custom-404-pages/) by creating a 404.html template file in your `/layouts` folder. When Hugo generates your site, the `404.html` file will be placed in the root.
+
+404 pages will have all the regular [page variables][pagevars] available to use in the templates.
+
+In addition to the standard page variables, the 404 page has access to all site content accessible from `.Pages`.
+
+```
+▾ layouts/
+ 404.html
+```
+
+## 404.html
+
+This is a basic example of a 404.html template:
+
+{{< code file="layouts/404.html" download="404.html" >}}
+{{ define "main"}}
+ <main id="main">
+ <div>
+ <h1 id="title"><a href="{{ "/" | relURL }}">Go Home</a></h1>
+ </div>
+ </main>
+{{ end }}
+{{< /code >}}
+
+## Automatic Loading
+
+Your 404.html file can be set to load automatically when a visitor enters a mistaken URL path, dependent upon the web serving environment you are using. For example:
+
+* [GitHub Pages](/hosting-and-deployment/hosting-on-github/). The 404 page is automatic.
+* Apache. You can specify `ErrorDocument 404 /404.html` in an `.htaccess` file in the root of your site.
+* Nginx. You might specify `error_page 404 /404.html;` in your `nginx.conf` file.
+* Amazon AWS S3. When setting a bucket up for static web serving, you can specify the error file from within the S3 GUI.
++* Amazon CloudFont. You can specify the page in the Error Pages section in the CloudFont Console. [Details here](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/custom-error-pages.html)
+* Caddy Server. Using `errors { 404 /404.html }`. [Details here](https://caddyserver.com/docs/errors)
+
+{{% note %}}
+`hugo server` will not automatically load your custom `404.html` file, but you
+can test the appearance of your custom "not found" page by navigating your
+browser to `/404.html`.
+{{% /note %}}
+
+[pagevars]: /variables/page/
--- /dev/null
- [called directly in the Hugo docs]: https://github.com/gohugoio/hugo/blob/master/docs/content/templates/files.md
+---
+title: Local File Templates
+linktitle: Local File Templates
+description: Hugo's `readerDir` and `readFile` functions make it easy to traverse your project's directory structure and write file contents to your templates.
+godocref: https://golang.org/pkg/os/#FileInfo
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-02-01
+categories: [templates]
+keywords: [files,directories]
+menu:
+ docs:
+ parent: "templates"
+ weight: 110
+weight: 110
+sections_weight: 110
+draft: false
+aliases: [/extras/localfiles/,/templates/local-files/]
+toc: true
+---
+
+## Traverse Local Files
+
+With Hugo's [`readDir`][readDir] and [`readFile`][readFile] template functions, you can traverse your website's files on your server.
+
+## Use `readDir`
+
+The [`readDir` function][readDir] returns an array of [`os.FileInfo`][osfileinfo]. It takes the file's `path` as a single string argument. This path can be to any directory of your website (i.e., as found on your server's file system).
+
+Whether the path is absolute or relative does not matter because---at least for `readDir`---the root of your website (typically `./public/`) in effect becomes both:
+
+1. The file system root
+2. The current working directory
+
+### `readDir` Example: List Directory Files
+
+This shortcode creates a link to each of the files in a directory---display as the file's basename---along with the file's size in bytes.
+
+{{< code file="layouts/shortcodes/directoryindex.html" download="directoryindex.html" >}}
+{{< readfile file="/themes/gohugoioTheme/layouts/shortcodes/directoryindex.html" >}}
+{{< /code >}}
+
+You can then call the shortcode as follows inside of your content's markup:
+
+```
+{{</* directoryindex path="/static/css" pathURL="/css" */>}}
+```
+
+The above shortcode [is part of the code for the Hugo docs][dirindex]. Here it lists this site's CSS files:
+
+{{< directoryindex path="/themes/gohugoioTheme/static/dist" pathURL="/css" >}}
+
+{{% note "Slashes are Important" %}}
+The initial slash `/` in `pathURL` is important in the `directoryindex` shortcode. Otherwise, `pathURL` becomes relative to the current web page.
+{{% /note %}}
+
+## Use `readFile`
+
+The [`readfile` function][readFile] reads a file from disk and converts it into a string to be manipulated by other Hugo functions or added as-is. `readFile` takes the file, including path, as an argument passed to the function.
+
+To use the `readFile` function in your templates, make sure the path is relative to your *Hugo project's root directory*:
+
+```
+{{ readFile "/content/templates/local-file-templates" }}
+```
+
+### `readFile` Example: Add a Project File to Content
+
+As `readFile` is a function, it is only available to you in your templates and not your content. However, we can create a simple [shortcode template][sct] that calls `readFile`, passes the first argument through the function, and then allows an optional second argument to send the file through the Blackfriday markdown processor. The pattern for adding this shortcode to your content will be as follows:
+
+```
+{{</* readfile file="/path/to/local/file.txt" markdown="true" */>}}
+```
+
+{{% warning %}}
+If you are going to create [custom shortcodes](/templates/shortcode-templates/) with `readFile` for a theme, note that usage of the shortcode will refer to the project root and *not* your `themes` directory.
+{{% /warning %}}
+
+Here is the templating for our new `readfile` shortcode:
+
+{{< code file="layouts/shortcodes/readfile.html" download="readfile.html" >}}
+{{< readfile file="/themes/gohugoioTheme/layouts/shortcodes/readfile.html">}}
+{{< /code >}}
+
+This `readfile` shortcode is [also part of the Hugo docs][readfilesource]. So is [`testing.txt`][testfile], which we will call in this example by passing it into our new `readfile` shortcode as follows:
+
+```
+{{</* readfile file="/content/en/readfiles/testing.txt" */>}}
+```
+
+The output "string" for this shortcode declaration will be the following:
+
+```
+{{< readfile file="/content/en/readfiles/testing.txt" >}}
+```
+
+However, if we want Hugo to pass this string through Blackfriday, we should add the `markdown="true"` optional parameter:
+
+```
+{{</* readfile file="/content/en/readfiles/testing.txt" markdown="true" */>}}
+```
+
+And here is the result as [called directly in the Hugo docs][] and rendered for display:
+
+{{< readfile file="/content/en/readfiles/testing.txt" markdown="true">}}
+
- [readfilesource]: https://github.com/gohugoio/hugo/blob/master/
- [testfile]: https://github.com/gohugoio/hugo/blob/master/docs/testfile
++[called directly in the Hugo docs]: https://github.com/gohugoio/hugoDocs/blob/master/content/en/templates/files.md
+[dirindex]: https://github.com/gohugoio/hugo/blob/master/docs/layouts/shortcodes/directoryindex.html
+[osfileinfo]: https://golang.org/pkg/os/#FileInfo
+[readDir]: /functions/readdir/
+[readFile]: /functions/readfile/
+[sc]: /content-management/shortcodes/
+[sct]: /templates/shortcode-templates/
++[readfilesource]: https://github.com/gohugoio/hugoDocs/blob/master/layouts/shortcodes/readfile.html
++[testfile]: https://github.com/gohugoio/hugoDocs/blob/master/content/en/readfiles/testing.txt
--- /dev/null
- The following is only a primer on Go templates. For an in-depth look into Go templates, check the official [Go docs](http://golang.org/pkg/html/template/).
+---
+title: Introduction to Hugo Templating
+linktitle: Introduction
+description: Hugo uses Go's `html/template` and `text/template` libraries as the basis for the templating.
+godocref: https://golang.org/pkg/html/template/
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-02-25
+categories: [templates,fundamentals]
+keywords: [go]
+menu:
+ docs:
+ parent: "templates"
+ weight: 10
+weight: 10
+sections_weight: 10
+draft: false
+aliases: [/layouts/introduction/,/layout/introduction/, /templates/go-templates/]
+toc: true
+---
+
+{{% note %}}
- Go templates provide an extremely simple template language that adheres to the belief that only the most basic of logic belongs in the template or view layer.
++The following is only a primer on Go Templates. For an in-depth look into Go Templates, check the official [Go docs](http://golang.org/pkg/html/template/).
+{{% /note %}}
+
- Go templates are HTML files with the addition of [variables][variables] and [functions][functions]. Go template variables and functions are accessible within `{{ }}`.
++Go Templates provide an extremely simple template language that adheres to the belief that only the most basic of logic belongs in the template or view layer.
+
+{{< youtube gnJbPO-GFIw >}}
+
+## Basic Syntax
+
- ```
- {{ foo }}
++Go Templates are HTML files with the addition of [variables][variables] and [functions][functions]. Go Template variables and functions are accessible within `{{ }}`.
+
+### Access a Predefined Variable
+
- Parameters for functions are separated using spaces. The following example calls the `add` function with inputs of `1` and `2`:
++A _predefined variable_ could be a variable already existing in the
++current scope (like the `.Title` example in the [Variables]({{< relref
++"#variables" >}}) section below) or a custom variable (like the
++`$address` example in that same section).
++
++
++```go-html-template
++{{ .Title }}
++{{ $address }}
+```
+
- ```
++Parameters for functions are separated using spaces. The general syntax is:
+
+```
++{{ FUNCTION ARG1 ARG2 .. }}
++```
++
++The following example calls the `add` function with inputs of `1` and `2`:
++
++```go-html-template
+{{ add 1 2 }}
+```
+
+#### Methods and Fields are Accessed via dot Notation
+
+Accessing the Page Parameter `bar` defined in a piece of content's [front matter][].
+
- ```
++```go-html-template
+{{ .Params.bar }}
+```
+
+#### Parentheses Can be Used to Group Items Together
+
- ## Variables
++```go-html-template
+{{ if or (isset .Params "alt") (isset .Params "caption") }} Caption {{ end }}
+```
+
- Each Go template gets a data object. In Hugo, each template is passed a `Page`. See [variables][] for more information.
++## Variables {#variables}
+
- This is how you access a `Page` variable from a template:
++Each Go Template gets a data object. In Hugo, each template is passed
++a `Page`. In the below example, `.Title` is one of the elements
++accessible in that [`Page` variable][pagevars].
+
- ```
++With the `Page` being the default scope of a template, the `Title`
++element in current scope (`.` -- "the **dot**") is accessible simply
++by the dot-prefix (`.Title`):
+
- ```
- {{ $address := "123 Main St."}}
++```go-html-template
+<title>{{ .Title }}</title>
+```
+
+Values can also be stored in custom variables and referenced later:
+
- Variables defined inside `if` conditionals and similar are not visible on the outside. See [https://github.com/golang/go/issues/10608](https://github.com/golang/go/issues/10608).
++{{% note %}}
++The custom variables need to be prefixed with `$`.
++{{% /note %}}
++
++```go-html-template
++{{ $address := "123 Main St." }}
+{{ $address }}
+```
+
+{{% warning %}}
-
++For Hugo v0.47 and older versions, variables defined inside `if`
++conditionals and similar are not visible on the outside.
++See [https://github.com/golang/go/issues/10608](https://github.com/golang/go/issues/10608).
+
+Hugo has created a workaround for this issue in [Scratch](/functions/scratch).
- Go templates only ship with a few basic functions but also provide a mechanism for applications to extend the original set.
+{{% /warning %}}
+
++For **Hugo v0.48** and newer, variables can be re-defined using the
++new `=` operator (new in Go 1.11).
++
++Below example will work only in these newer Hugo versions. The example
++prints "Var is Hugo Home" on the home page, and "Var is Hugo Page" on
++all other pages:
++
++```go-html-template
++{{ $var := "Hugo Page" }}
++{{ if .IsHome }}
++ {{ $var = "Hugo Home" }}
++{{ end }}
++Var is {{ $var }}
++```
++
+## Functions
+
- ```
++Go Templates only ship with a few basic functions but also provide a mechanism for applications to extend the original set.
+
+[Hugo template functions][functions] provide additional functionality specific to building websites. Functions are called by using their name followed by the required parameters separated by spaces. Template functions cannot be added without recompiling Hugo.
+
+### Example 1: Adding Numbers
+
- => 3
++```go-html-template
+{{ add 1 2 }}
- ```
++<!-- prints 3 -->
+```
+
+### Example 2: Comparing Numbers
+
- => true (i.e., since 1 is less than 2)
++```go-html-template
+{{ lt 1 2 }}
- Note that both examples make use of Go template's [math functions][].
++<!-- prints true (i.e., since 1 is less than 2) -->
+```
+
- There are more boolean operators than those listed in the Hugo docs in the [Go template documentation](http://golang.org/pkg/text/template/#hdr-Functions).
++Note that both examples make use of Go Template's [math functions][].
+
+{{% note "Additional Boolean Operators" %}}
- Example:
++There are more boolean operators than those listed in the Hugo docs in the [Go Template documentation](http://golang.org/pkg/text/template/#hdr-Functions).
+{{% /note %}}
+
+## Includes
+
+When including another template, you will need to pass it the data that it would
+need to access.
+
+{{% note %}}
+To pass along the current context, please remember to include a trailing **dot**.
+{{% /note %}}
+
+The templates location will always be starting at the `layouts/` directory
+within Hugo.
+
+### Partial
+
+The [`partial`][partials] function is used to include *partial* templates using
+the syntax `{{ partial "<PATH>/<PARTIAL>.<EXTENSION>" . }}`.
+
- ```
++Example of including a `layouts/partials/header.html` partial:
+
- The `template` function was used to include *partial* templates in much older
- Hugo versions. Now it is still useful for calling [*internal*
- templates][internal_templates]:
++```go-html-template
+{{ partial "header.html" . }}
+```
+
+### Template
+
- ```
++The `template` function was used to include *partial* templates
++in much older Hugo versions. Now it useful only for calling
++[*internal* templates][internal_templates]. The syntax is `{{ template
++"_internal/<TEMPLATE>.<EXTENSION>" . }}`.
+
- Go templates provide the most basic iteration and conditional logic.
++{{% note %}}
++The available **internal** templates can be found
++[here](https://github.com/gohugoio/hugo/tree/master/tpl/tplimpl/embedded/templates).
++{{% /note %}}
++
++Example of including the internal `opengraph.html` template:
++
++```go-html-template
+{{ template "_internal/opengraph.html" . }}
+```
+
+## Logic
+
- Just like in Go, the Go templates make heavy use of `range` to iterate over
- a map, array, or slice. The following are different examples of how to use
- range.
++Go Templates provide the most basic iteration and conditional logic.
+
+### Iteration
+
- #### Example 1: Using Context
++The Go Templates make heavy use of `range` to iterate over a _map_,
++_array_, or _slice_. The following are different examples of how to
++use `range`.
+
- ```
- {{ range array }}
- {{ . }}
++#### Example 1: Using Context (`.`)
+
- #### Example 2: Declaring Value => Variable name
++```go-html-template
++{{ range $array }}
++ {{ . }} <!-- The . represents an element in $array -->
+{{ end }}
+```
+
- ```
- {{range $element := array}}
- {{ $element }}
++#### Example 2: Declaring a variable name for an array element's value
+
- #### Example 3: Declaring Key-Value Variable Name
++```go-html-template
++{{ range $elem_val := $array }}
++ {{ $elem_val }}
+{{ end }}
+```
+
- {{range $index, $element := array}}
- {{ $index }}
- {{ $element }}
++#### Example 3: Declaring variable names for an array element's index _and_ value
++
++For an array or slice, the first declared variable will map to each
++element's index.
+
++```go-html-template
++{{ range $elem_index, $elem_val := $array }}
++ {{ $elem_index }} -- {{ $elem_val }}
++{{ end }}
+```
- `if`, `else`, `with`, `or`, and `and` provide the framework for handling conditional logic in Go Templates. Like `range`, each statement is closed with an `{{end}}`.
++
++#### Example 4: Declaring variable names for a map element's key _and_ value
++
++For a map, the first declared variable will map to each map element's
++key.
++
++```go-html-template
++{{ range $elem_key, $elem_val := $map }}
++ {{ $elem_key }} -- {{ $elem_val }}
+{{ end }}
+```
+
+### Conditionals
+
- Go Templates treat the following values as false:
++`if`, `else`, `with`, `or`, and `and` provide the framework for handling conditional logic in Go Templates. Like `range`, each statement is closed with an `{{ end }}`.
+
- * false
- * 0
- * any zero-length array, slice, map, or string
++Go Templates treat the following values as **false**:
+
- #### Example 1: `if`
++- `false` (boolean)
++- 0 (integer)
++- any zero-length array, slice, map, or string
+
- ```
- {{ if isset .Params "title" }}<h4>{{ index .Params "title" }}</h4>{{ end }}
- ```
++#### Example 1: `with`
+
- #### Example 2: `if` … `else`
++It is common to write "if something exists, do this" kind of
++statements using `with`.
+
- ```
- {{ if isset .Params "alt" }}
- {{ index .Params "alt" }}
- {{else}}
- {{ index .Params "caption" }}
++{{% note %}}
++`with` rebinds the context `.` within its scope (just like in `range`).
++{{% /note %}}
+
- #### Example 3: `and` & `or`
++It skips the block if the variable is absent, or if it evaluates to
++"false" as explained above.
++
++```go-html-template
++{{ with .Params.title }}
++ <h4>{{ . }}</h4>
+{{ end }}
+```
+
- ```
- {{ if and (or (isset .Params "title") (isset .Params "caption")) (isset .Params "attr")}}
++#### Example 2: `with` .. `else`
+
- #### Example 4: `with`
++Below snippet uses the "description" front-matter parameter's value if
++set, else uses the default `.Summary` [Page variable][pagevars]:
++
++
++```go-html-template
++{{ with .Param "description" }}
++ {{ . }}
++{{ else }}
++ {{ .Summary }}
++{{ end }}
+```
+
- An alternative way of writing "`if`" and then referencing the same value
- is to use "`with`" instead. `with` rebinds the context `.` within its scope
- and skips the block if the variable is absent.
++See the [`.Param` function][param].
+
- The first example above could be simplified as:
++#### Example 3: `if`
+
- {{ with .Params.title }}<h4>{{ . }}</h4>{{ end }}
- ```
++An alternative (and a more verbose) way of writing `with` is using
++`if`. Here, the `.` does not get rebinded.
+
++Below example is "Example 1" rewritten using `if`:
++
++```go-html-template
++{{ if isset .Params "title" }}
++ <h4>{{ index .Params "title" }}</h4>
++{{ end }}
+```
- #### Example 5: `if` … `else if`
+
- {{ if isset .Params "alt" }}
- {{ index .Params "alt" }}
- {{ else if isset .Params "caption" }}
- {{ index .Params "caption" }}
++#### Example 4: `if` .. `else`
++
++Below example is "Example 2" rewritten using `if` .. `else`, and using
++[`isset` function][isset] + `.Params` variable (different from the
++[`.Param` **function**][param]) instead:
+
++```go-html-template
++{{ if (isset .Params "description") }}
++ {{ index .Params "description" }}
++{{ else }}
++ {{ .Summary }}
++{{ end }}
+```
- One of the most powerful components of Go templates is the ability to stack actions one after another. This is done by using pipes. Borrowed from Unix pipes, the concept is simple: each pipeline's output becomes the input of the following pipe.
++
++#### Example 5: `if` .. `else if` .. `else`
++
++Unlike `with`, `if` can contain `else if` clauses too.
++
++```go-html-template
++{{ if (isset .Params "description") }}
++ {{ index .Params "description" }}
++{{ else if (isset .Params "summary") }}
++ {{ index .Params "summary" }}
++{{ else }}
++ {{ .Summary }}
+{{ end }}
+```
+
++#### Example 6: `and` & `or`
++
++```go-html-template
++{{ if (and (or (isset .Params "title") (isset .Params "caption")) (isset .Params "attr")) }}
++```
++
+## Pipes
+
- Because of the very simple syntax of Go templates, the pipe is essential to being able to chain together function calls. One limitation of the pipes is that they can only work with a single value and that value becomes the last parameter of the next pipeline.
++One of the most powerful components of Go Templates is the ability to stack actions one after another. This is done by using pipes. Borrowed from Unix pipes, the concept is simple: each pipeline's output becomes the input of the following pipe.
+
- ```
++Because of the very simple syntax of Go Templates, the pipe is essential to being able to chain together function calls. One limitation of the pipes is that they can only work with a single value and that value becomes the last parameter of the next pipeline.
+
+A few simple examples should help convey how to use the pipe.
+
+### Example 1: `shuffle`
+
+The following two examples are functionally the same:
+
- ```
++```go-html-template
+{{ shuffle (seq 1 5) }}
+```
+
+
- The following accesses the page parameter called "disqus_url" and escapes the HTML. This example also uses the [`index` function][index], which is built into Go templates:
++```go-html-template
+{{ (seq 1 5) | shuffle }}
+```
+
+### Example 2: `index`
+
- ```
++The following accesses the page parameter called "disqus_url" and escapes the HTML. This example also uses the [`index` function][index], which is built into Go Templates:
+
- ```
++```go-html-template
+{{ index .Params "disqus_url" | html }}
+```
+
+### Example 3: `or` with `isset`
+
- ```
++```go-html-template
+{{ if or (or (isset .Params "title") (isset .Params "caption")) (isset .Params "attr") }}
+Stuff Here
+{{ end }}
+```
+
+Could be rewritten as
+
- ```
++```go-html-template
+{{ if isset .Params "caption" | or isset .Params "title" | or isset .Params "attr" }}
+Stuff Here
+{{ end }}
+```
+
+### Example 4: Internet Explorer Conditional Comments {#ie-conditional-comments}
+
+By default, Go Templates remove HTML comments from output. This has the unfortunate side effect of removing Internet Explorer conditional comments. As a workaround, use something like this:
+
- ```
++```go-html-template
+{{ "<!--[if lt IE 9]>" | safeHTML }}
+ <script src="html5shiv.js"></script>
+{{ "<![endif]-->" | safeHTML }}
+```
+
+Alternatively, you can use the backtick (`` ` ``) to quote the IE conditional comments, avoiding the tedious task of escaping every double quotes (`"`) inside, as demonstrated in the [examples](http://golang.org/pkg/text/template/#hdr-Examples) in the Go text/template documentation:
+
- ## Context (aka "the dot")
++```go-html-template
+{{ `<!--[if lt IE 7]><html class="no-js lt-ie9 lt-ie8 lt-ie7"><![endif]-->` | safeHTML }}
+```
+
- The most easily overlooked concept to understand about Go templates is that `{{ . }}` always refers to the current context. In the top level of your template, this will be the data set made available to it. Inside of an iteration, however, it will have the value of the current item in the loop; i.e., `{{ . }}` will no longer refer to the data available to the entire page. If you need to access page-level data (e.g., page params set in front matter) from within the loop, you will likely want to do one of the following:
++## Context (aka "the dot") {#the-dot}
++
++The most easily overlooked concept to understand about Go Templates is
++that `{{ . }}` always refers to the **current context**.
+
- For instance, the following Go template will include the newlines and horizontal tab in its HTML output:
++- In the top level of your template, this will be the data set made
++ available to it.
++- Inside of an iteration, however, it will have the value of the
++ current item in the loop; i.e., `{{ . }}` will no longer refer to
++ the data available to the entire page.
++
++If you need to access page-level data (e.g., page params set in front
++matter) from within the loop, you will likely want to do one of the
++following:
+
+### 1. Define a Variable Independent of Context
+
+The following shows how to define a variable independent of the context.
+
+{{< code file="tags-range-with-page-variable.html" >}}
+{{ $title := .Site.Title }}
+<ul>
+{{ range .Params.tags }}
+ <li>
+ <a href="/tags/{{ . | urlize }}">{{ . }}</a>
+ - {{ $title }}
+ </li>
+{{ end }}
+</ul>
+{{< /code >}}
+
+{{% note %}}
+Notice how once we have entered the loop (i.e. `range`), the value of `{{ . }}` has changed. We have defined a variable outside of the loop (`{{$title}}`) that we've assigned a value so that we have access to the value from within the loop as well.
+{{% /note %}}
+
+### 2. Use `$.` to Access the Global Context
+
+`$` has special significance in your templates. `$` is set to the starting value of `.` ("the dot") by default. This is a [documented feature of Go text/template][dotdoc]. This means you have access to the global context from anywhere. Here is an equivalent example of the preceding code block but now using `$` to grab `.Site.Title` from the global context:
+
+{{< code file="range-through-tags-w-global.html" >}}
+<ul>
+{{ range .Params.tags }}
+ <li>
+ <a href="/tags/{{ . | urlize }}">{{ . }}</a>
+ - {{ $.Site.Title }}
+ </li>
+{{ end }}
+</ul>
+{{< /code >}}
+
+{{% warning "Don't Redefine the Dot" %}}
+The built-in magic of `$` would cease to work if someone were to mischievously redefine the special character; e.g. `{{ $ := .Site }}`. *Don't do it.* You may, of course, recover from this mischief by using `{{ $ := . }}` in a global context to reset `$` to its default value.
+{{% /warning %}}
+
+## Whitespace
+
+Go 1.6 includes the ability to trim the whitespace from either side of a Go tag by including a hyphen (`-`) and space immediately beside the corresponding `{{` or `}}` delimiter.
+
- ```
++For instance, the following Go Template will include the newlines and horizontal tab in its HTML output:
+
- ```
++```go-html-template
+<div>
+ {{ .Title }}
+</div>
+```
+
+Which will output:
+
- ```
++```html
+<div>
+ Hello, World!
+</div>
+```
+
+Leveraging the `-` in the following example will remove the extra white space surrounding the `.Title` variable and remove the newline:
+
- ```
++```go-html-template
+<div>
+ {{- .Title -}}
+</div>
+```
+
+Which then outputs:
+
- Go considers the following characters whitespace:
++```html
+<div>Hello, World!</div>
+```
+
- ### Go templates comments
++Go considers the following characters _whitespace_:
+
+* <kbd>space</kbd>
+* horizontal <kbd>tab</kbd>
+* carriage <kbd>return</kbd>
+* newline
+
+## Comments
+
+In order to keep your templates organized and share information throughout your team, you may want to add comments to your templates. There are two ways to do that with Hugo.
+
- Go templates support `{{/*` and `*/}}` to open and close a comment block. Nothing within that block will be rendered.
++### Go Templates comments
+
- ```
++Go Templates support `{{/*` and `*/}}` to open and close a comment block. Nothing within that block will be rendered.
+
+For example:
+
- ```
++```go-html-template
+Bonsoir, {{/* {{ add 0 + 2 }} */}}Eliott.
+```
+
+Will render `Bonsoir, Eliott.`, and not care about the syntax error (`add 0 + 2`) in the comment block.
+
+### HTML comments
+
+If you need to produce HTML comments from your templates, take a look at the [Internet Explorer conditional comments](#ie-conditional-comments) example. If you need variables to construct such HTML comments, just pipe `printf` to `safeHTML`. For example:
+
- #### HTML comments containing Go templates
++```go-html-template
+{{ printf "<!-- Our website is named: %s -->" .Site.Title | safeHTML }}
+```
+
- Do **not** try to comment out Go template code using HTML comments.
++#### HTML comments containing Go Templates
+
+HTML comments are by default stripped, but their content is still evaluated. That means that although the HTML comment will never render any content to the final HTML pages, code contained within the comment may fail the build process.
+
+{{% note %}}
- ```
++Do **not** try to comment out Go Template code using HTML comments.
+{{% /note %}}
+
- The templating engine will strip the content within the HTML comment, but will first evaluate any Go template code if present within. So the above example will render `Emma Goldman`, as the `$author` variable got evaluated in the HTML comment. But the build would have failed if that code in the HTML comment had an error.
++```go-html-template
+<!-- {{ $author := "Emma Goldman" }} was a great woman. -->
+{{ $author }}
+```
+
- Here is the example front matter:
++The templating engine will strip the content within the HTML comment, but will first evaluate any Go Template code if present within. So the above example will render `Emma Goldman`, as the `$author` variable got evaluated in the HTML comment. But the build would have failed if that code in the HTML comment had an error.
+
+## Hugo Parameters
+
+Hugo provides the option of passing values to your template layer through your [site configuration][config] (i.e. for site-wide values) or through the metadata of each specific piece of content (i.e. the [front matter][]). You can define any values of any type and use them however you want in your templates, as long as the values are supported by the front matter format specified via `metaDataFormat` in your configuration file.
+
+## Use Content (`Page`) Parameters
+
+You can provide variables to be used by templates in individual content's [front matter][].
+
+An example of this is used in the Hugo docs. Most of the pages benefit from having the table of contents provided, but sometimes the table of contents doesn't make a lot of sense. We've defined a `notoc` variable in our front matter that will prevent a table of contents from rendering when specifically set to `true`.
+
- {{end}}
++Here is the example front matter (YAML):
+
+```
+---
+title: Roadmap
+lastmod: 2017-03-05
+date: 2013-11-18
+notoc: true
+---
+```
+
+Here is an example of corresponding code that could be used inside a `toc.html` [partial template][partials]:
+
+{{< code file="layouts/partials/toc.html" download="toc.html" >}}
+{{ if not .Params.notoc }}
+<aside>
+ <header>
+ <a href="#{{.Title | urlize}}">
+ <h3>{{.Title}}</h3>
+ </a>
+ </header>
+ {{.TableOfContents}}
+</aside>
+<a href="#" id="toc-toggle"></a>
- ```
- {{if .Site.Params.copyrighthtml}}<footer>
- <div class="text-center">{{.Site.Params.CopyrightHTML | safeHTML}}</div>
- </footer>{{end}}
++{{ end }}
+{{< /code >}}
+
+We want the *default* behavior to be for pages to include a TOC unless otherwise specified. This template checks to make sure that the `notoc:` field in this page's front matter is not `true`.
+
+## Use Site Configuration Parameters
+
+You can arbitrarily define as many site-level parameters as you want in your [site's configuration file][config]. These parameters are globally available in your templates.
+
+For instance, you might declare the following:
+
+{{< code-toggle file="config" >}}
+params:
+ copyrighthtml: "Copyright © 2017 John Doe. All Rights Reserved."
+ twitteruser: "spf13"
+ sidebarrecentlimit: 5
+{{< /code >}}
+
+Within a footer layout, you might then declare a `<footer>` that is only rendered if the `copyrighthtml` parameter is provided. If it *is* provided, you will then need to declare the string is safe to use via the [`safeHTML` function][safehtml] so that the HTML entity is not escaped again. This would let you easily update just your top-level config file each January 1st, instead of hunting through your templates.
+
- {{with .Site.Params.twitteruser}}
- <div>
- <a href="https://twitter.com/{{.}}" rel="author">
- <img src="/images/twitter.png" width="48" height="48" title="Twitter: {{.}}" alt="Twitter"></a>
- </div>
- {{end}}
++```go-html-template
++{{ if .Site.Params.copyrighthtml }}
++ <footer>
++ <div class="text-center">{{.Site.Params.CopyrightHTML | safeHTML}}</div>
++ </footer>
++{{ end }}
+```
+
+An alternative way of writing the "`if`" and then referencing the same value is to use [`with`][with] instead. `with` rebinds the context (`.`) within its scope and skips the block if the variable is absent:
+
+{{< code file="layouts/partials/twitter.html" >}}
- ```
++{{ with .Site.Params.twitteruser }}
++ <div>
++ <a href="https://twitter.com/{{.}}" rel="author">
++ <img src="/images/twitter.png" width="48" height="48" title="Twitter: {{.}}" alt="Twitter"></a>
++ </div>
++{{ end }}
+{{< /code >}}
+
+Finally, you can pull "magic constants" out of your layouts as well. The following uses the [`first`][first] function, as well as the [`.RelPermalink`][relpermalink] page variable and the [`.Site.Pages`][sitevars] site variable.
+
- <li><a href="{{.RelPermalink}}">{{.Title}}</a></li>
++```go-html-template
+<nav>
+ <h1>Recent Posts</h1>
+ <ul>
+ {{- range first .Site.Params.SidebarRecentLimit .Site.Pages -}}
- {{ if ge .Date.Unix .Now.Unix }}
- <li>
- <!-- add span for event type -->
- <span>{{ .Type | title }} —</span>
- {{ .Title }} on
- <!-- add span for event date -->
- <span>{{ .Date.Format "2 January at 3:04pm" }}</span>
- at {{ .Params.place }}
- </li>
- {{ end }}
++ <li><a href="{{.RelPermalink}}">{{.Title}}</a></li>
+ {{- end -}}
+ </ul>
+</nav>
+```
+
+## Example: Show Only Upcoming Events
+
+Go allows you to do more than what's shown here. Using Hugo's [`where` function][where] and Go built-ins, we can list only the items from `content/events/` whose date (set in a content file's [front matter][]) is in the future. The following is an example [partial template][partials]:
+
+{{< code file="layouts/partials/upcoming-events.html" download="upcoming-events.html" >}}
+<h4>Upcoming Events</h4>
+<ul class="upcoming-events">
+{{ range where .Pages.ByDate "Section" "events" }}
++ {{ if ge .Date.Unix now.Unix }}
++ <li>
++ <!-- add span for event type -->
++ <span>{{ .Type | title }} —</span>
++ {{ .Title }} on
++ <!-- add span for event date -->
++ <span>{{ .Date.Format "2 January at 3:04pm" }}</span>
++ at {{ .Params.place }}
++ </li>
++ {{ end }}
+{{ end }}
+</ul>
+{{< /code >}}
+
+
+[`where` function]: /functions/where/
+[config]: /getting-started/configuration/
+[dotdoc]: http://golang.org/pkg/text/template/#hdr-Variables
+[first]: /functions/first/
+[front matter]: /content-management/front-matter/
+[functions]: /functions/ "See the full list of Hugo's templating functions with a quick start reference guide and basic and advanced examples."
+[Go html/template]: http://golang.org/pkg/html/template/ "Godocs references for Go's html templating"
+[gohtmltemplate]: http://golang.org/pkg/html/template/ "Godocs references for Go's html templating"
+[index]: /functions/index/
+[math functions]: /functions/math/
+[partials]: /templates/partials/ "Link to the partial templates page inside of the templating section of the Hugo docs"
+[internal_templates]: /templates/internal/
+[relpermalink]: /variables/page/
+[safehtml]: /functions/safehtml/
+[sitevars]: /variables/site/
++[pagevars]: /variables/page/
+[variables]: /variables/ "See the full extent of page-, site-, and other variables that Hugo make available to you in your templates."
+[where]: /functions/where/
+[with]: /functions/with/
+[godocsindex]: http://golang.org/pkg/text/template/ "Godocs page for index function"
++[param]: /functions/param/
++[isset]: /functions/isset/
--- /dev/null
- ```
+---
+title: Taxonomy Templates
+# linktitle:
+description: Taxonomy templating includes taxonomy list pages, taxonomy terms pages, and using taxonomies in your single page templates.
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-02-01
+categories: [templates]
+keywords: [taxonomies,metadata,front matter,terms,templates]
+menu:
+ docs:
+ parent: "templates"
+ weight: 50
+weight: 50
+sections_weight: 50
+draft: false
+aliases: [/taxonomies/displaying/,/templates/terms/,/indexes/displaying/,/taxonomies/templates/,/indexes/ordering/, /templates/taxonomies/, /templates/taxonomy/]
+toc: true
+---
+
+<!-- NOTE! Check on https://github.com/gohugoio/hugo/issues/2826 for shifting of terms' pages to .Data.Pages AND
+https://discourse.gohugo.io/t/how-to-specify-category-slug/4856/15 for original discussion.-->
+
+Hugo includes support for user-defined groupings of content called **taxonomies**. Taxonomies are classifications that demonstrate logical relationships between content. See [Taxonomies under Content Management](/content-management/taxonomies) if you are unfamiliar with how Hugo leverages this powerful feature.
+
+Hugo provides multiple ways to use taxonomies throughout your project templates:
+
+* Order the way content associated with a taxonomy term is displayed in a [taxonomy list template](#taxonomy-list-template)
+* Order the way the terms for a taxonomy are displayed in a [taxonomy terms template](#taxonomy-terms-template)
+* List a single content's taxonomy terms within a [single page template][]
+
+## Taxonomy List Templates
+
+Taxonomy list page templates are lists and therefore have all the variables and methods available to [list pages][lists].
+
+### Taxonomy List Template Lookup Order
+
+See [Template Lookup](/templates/lookup-order/).
+
+## Taxonomy Terms Template
+
+### Taxonomy Terms Templates Lookup Order
+
+See [Template Lookup](/templates/lookup-order/).
+
+### Taxonomy Methods
+
+A Taxonomy is a `map[string]WeightedPages`.
+
+.Get(term)
+: Returns the WeightedPages for a term.
+
+.Count(term)
+: The number of pieces of content assigned to this term.
+
+.Alphabetical
+: Returns an OrderedTaxonomy (slice) ordered by Term.
+
+.ByCount
+: Returns an OrderedTaxonomy (slice) ordered by number of entries.
+
+.Reverse
+: Returns an OrderedTaxonomy (slice) in reverse order. Must be used with an OrderedTaxonomy.
+
+### OrderedTaxonomy
+
+Since Maps are unordered, an OrderedTaxonomy is a special structure that has a defined order.
+
- ```
++```go
+[]struct {
+ Name string
+ WeightedPages WeightedPages
+}
+```
+
+Each element of the slice has:
+
+.Term
+: The Term used.
+
+.WeightedPages
+: A slice of Weighted Pages.
+
+.Count
+: The number of pieces of content assigned to this term.
+
+.Pages
+: All Pages assigned to this term. All [list methods][renderlists] are available to this.
+
+## WeightedPages
+
+WeightedPages is simply a slice of WeightedPage.
+
- If you need to display custom metadata for each taxonomy term, you will need to create a page for that term at `/content/<TAXONOMY>/<TERM>/_index.md` and add your metadata in it's front matter, [as explained in the taxonomies documentation](/content-management/taxonomies/#add-custom-meta-data-to-a-taxonomy-term). Based on the Actors taxonomy example shown there, within your taxonomy terms template, you may access your custom fields by iterating through the variable `.Pages` as such:
++```go
+type WeightedPages []WeightedPage
+```
+
+.Count(term)
+: The number of pieces of content assigned to this term.
+
+.Pages
+: Returns a slice of pages, which then can be ordered using any of the [list methods][renderlists].
+
+## Displaying custom metadata in Taxonomy Terms Templates
+
- ```
++If you need to display custom metadata for each taxonomy term, you will need to create a page for that term at `/content/<TAXONOMY>/<TERM>/_index.md` and add your metadata in its front matter, [as explained in the taxonomies documentation](/content-management/taxonomies/#add-custom-meta-data-to-a-taxonomy-term). Based on the Actors taxonomy example shown there, within your taxonomy terms template, you may access your custom fields by iterating through the variable `.Pages` as such:
+
- {{ range .Pages }}
- <li>
- <a href="{{ .Permalink }}">{{ .Title }}</a>
- {{ .Params.wikipedia }}
- </li>
- {{ end }}
++```go-html-template
+<ul>
- ```
++ {{ range .Pages }}
++ <li>
++ <a href="{{ .Permalink }}">{{ .Title }}</a>
++ {{ .Params.wikipedia }}
++ </li>
++ {{ end }}
+</ul>
+```
+
+<!-- Begin /taxonomies/ordering/ -->
+
+## Order Taxonomies
+
+Taxonomies can be ordered by either alphabetical key or by the number of content pieces assigned to that key.
+
+### Order Alphabetically Example
+
- {{ $data := .Data }}
- {{ range $key, $value := .Data.Terms.Alphabetical }}
- <li><a href="{{ $.Site.LanguagePrefix }}/{{ $data.Plural }}/{{ $value.Name | urlize }}"> {{ $value.Name }} </a> {{ $value.Count }} </li>
- {{ end }}
++```go-html-template
+<ul>
- ```
++ {{ $type := .Type }}
++ {{ range $key, $value := .Data.Terms.Alphabetical }}
++ {{ $name := .Name }}
++ {{ $count := .Count }}
++ {{ with $.Site.GetPage (printf "/%s/%s" $type $name) }}
++ <li><a href="{{ .Permalink }}">{{ $name }}</a> {{ $count }}</li>
++ {{ end }}
++ {{ end }}
+</ul>
+```
+
+### Order by Popularity Example
+
- {{ $data := .Data }}
- {{ range $key, $value := .Data.Terms.ByCount }}
- <li><a href="{{ $.Site.LanguagePrefix }}/{{ $data.Plural }}/{{ $value.Name | urlize }}"> {{ $value.Name }} </a> {{ $value.Count }} </li>
- {{ end }}
++```go-html-template
+<ul>
- ```
++ {{ $type := .Type }}
++ {{ range $key, $value := .Data.Terms.ByCount }}
++ {{ $name := .Name }}
++ {{ $count := .Count }}
++ {{ with $.Site.GetPage (printf "/%s/%s" $type $name) }}
++ <li><a href="{{ .Permalink }}">{{ $name }}</a> {{ $count }}</li>
++ {{ end }}
++ {{ end }}
+</ul>
+```
+
+### Order by Least Popular Example
+
- {{ $data := .Data }}
- {{ range $key, $value := .Data.Terms.ByCount.Reverse }}
- <li><a href="{{ $.Site.LanguagePrefix }}/{{ $data.Plural }}/{{ $value.Name | urlize }}"> {{ $value.Name }} </a> {{ $value.Count }} </li>
- {{ end }}
++```go-html-template
+<ul>
- ```
- <ul id="tags">
- {{ range .Params.tags }}
- <li><a href="{{ "/tags/" | relLangURL }}{{ . | urlize }}">{{ . }}</a> </li>
- {{ end }}
++ {{ $type := .Type }}
++ {{ range $key, $value := .Data.Terms.ByCount.Reverse }}
++ {{ $name := .Name }}
++ {{ $count := .Count }}
++ {{ with $.Site.GetPage (printf "/%s/%s" $type $name) }}
++ <li><a href="{{ .Permalink }}">{{ $name }}</a> {{ $count }}</li>
++ {{ end }}
++ {{ end }}
+</ul>
+```
+
+<!-- [See Also Taxonomy Lists](/templates/list/) -->
+
+## Order Content within Taxonomies
+
+Hugo uses both `date` and `weight` to order content within taxonomies.
+
+Each piece of content in Hugo can optionally be assigned a date. It can also be assigned a weight for each taxonomy it is assigned to.
+
+When iterating over content within taxonomies, the default sort is the same as that used for [section and list pages]() first by weight then by date. This means that if the weights for two pieces of content are the same, than the more recent content will be displayed first. The default weight for any piece of content is 0.
+
+### Assign Weight
+
+Content can be assigned weight for each taxonomy that it's assigned to.
+
+```
++++
+tags = [ "a", "b", "c" ]
+tags_weight = 22
+categories = ["d"]
+title = "foo"
+categories_weight = 44
++++
+Front Matter with weighted tags and categories
+```
+
+The convention is `taxonomyname_weight`.
+
+In the above example, this piece of content has a weight of 22 which applies to the sorting when rendering the pages assigned to the "a", "b" and "c" values of the 'tag' taxonomy.
+
+It has also been assigned the weight of 44 when rendering the 'd' category.
+
+With this the same piece of content can appear in different positions in different taxonomies.
+
+Currently taxonomies only support the default ordering of content which is weight -> date.
+
+<!-- Begin /taxonomies/templates/ -->
+
+There are two different templates that the use of taxonomies will require you to provide.
+
+Both templates are covered in detail in the templates section.
+
+A [list template](/templates/list/) is any template that will be used to render multiple pieces of content in a single html page. This template will be used to generate all the automatically created taxonomy pages.
+
+A [taxonomy terms template](/templates/terms/) is a template used to
+generate the list of terms for a given template.
+
+<!-- Begin /taxonomies/displaying/ -->
+
+There are four common ways you can display the data in your
+taxonomies in addition to the automatic taxonomy pages created by hugo
+using the [list templates](/templates/list/):
+
+1. For a given piece of content, you can list the terms attached
+2. For a given piece of content, you can list other content with the same
+ term
+3. You can list all terms for a taxonomy
+4. You can list all taxonomies (with their terms)
+
+## Display a Single Piece of Content's Taxonomies
+
+Within your content templates, you may wish to display the taxonomies that piece of content is assigned to.
+
+Because we are leveraging the front matter system to define taxonomies for content, the taxonomies assigned to each content piece are located in the usual place (i.e., `.Params.<TAXONOMYPLURAL>`).
+
+### Example: List Tags in a Single Page Template
+
- ```
- {{ if .Params.directors }}
- <strong>Director{{ if gt (len .Params.directors) 1 }}s{{ end }}:</strong>
- {{ range $index, $director := .Params.directors }}{{ if gt $index 0 }}, {{ end }}<a href="{{ "directors/" | relURL }}{{ . | urlize }}">{{ . }}</a>{{ end }}
++```go-html-template
++{{ $taxo := "tags" }} <!-- Use the plural form here -->
++<ul id="{{ $taxo }}">
++ {{ range .Param $taxo }}
++ {{ $name := . }}
++ {{ with $.Site.GetPage (printf "/%s/%s" $taxo $name) }}
++ <li><a href="{{ .Permalink }}">{{ $name }}</a></li>
++ {{ end }}
++ {{ end }}
+</ul>
+```
+
+If you want to list taxonomies inline, you will have to take care of optional plural endings in the title (if multiple taxonomies), as well as commas. Let's say we have a taxonomy "directors" such as `directors: [ "Joel Coen", "Ethan Coen" ]` in the TOML-format front matter.
+
+To list such taxonomies, use the following:
+
+### Example: Comma-delimit Tags in a Single Page Template
+
- ```
++```go-html-template
++{{ $taxo := "directors" }} <!-- Use the plural form here -->
++{{ with .Param $taxo }}
++ <strong>Director{{ if gt (len .) 1 }}s{{ end }}:</strong>
++ {{ range $index, $director := . }}
++ {{- if gt $index 0 }}, {{ end -}}
++ {{ with $.Site.GetPage (printf "/%s/%s" $taxo $director) -}}
++ <a href="{{ .Permalink }}">{{ $director }}</a>
++ {{- end -}}
++ {{- end -}}
+{{ end }}
+```
+
+Alternatively, you may use the [delimit template function][delimit] as a shortcut if the taxonomies should just be listed with a separator. See {{< gh 2143 >}} on GitHub for discussion.
+
+## List Content with the Same Taxonomy Term
+
+If you are using a taxonomy for something like a series of posts, you can list individual pages associated with the same taxonomy. This is also a quick and dirty method for showing related content:
+
+### Example: Showing Content in Same Series
+
- {{ range .Site.Taxonomies.series.golang }}
- <li><a href="{{ .Page.RelPermalink }}">{{ .Page.Title }}</a></li>
- {{ end }}
++```go-html-template
+<ul>
- ```
++ {{ range .Site.Taxonomies.series.golang }}
++ <li><a href="{{ .Page.RelPermalink }}">{{ .Page.Title }}</a></li>
++ {{ end }}
+</ul>
+```
+
+## List All content in a Given taxonomy
+
+This would be very useful in a sidebar as “featured content”. You could even have different sections of “featured content” by assigning different terms to the content.
+
+### Example: Grouping "Featured" Content
+
- <li> {{ $key }} </li>
++```go-html-template
+<section id="menu">
+ <ul>
+ {{ range $key, $taxonomy := .Site.Taxonomies.featured }}
- <li hugo-nav="{{ .RelPermalink}}"><a href="{{ .Permalink}}"> {{ .LinkTitle }} </a> </li>
++ <li>{{ $key }}</li>
+ <ul>
+ {{ range $taxonomy.Pages }}
- ### Example: List All Site Tags
++ <li hugo-nav="{{ .RelPermalink}}"><a href="{{ .Permalink}}">{{ .LinkTitle }}</a></li>
+ {{ end }}
+ </ul>
+ {{ end }}
+ </ul>
+</section>
+```
+
+## Render a Site's Taxonomies
+
+If you wish to display the list of all keys for your site's taxonomy, you can retrieve them from the [`.Site` variable][sitevars] available on every page.
+
+This may take the form of a tag cloud, a menu, or simply a list.
+
+The following example displays all terms in a site's tags taxonomy:
+
- ```
++### Example: List All Site Tags {#example-list-all-site-tags}
+
- {{ range $name, $taxonomy := .Site.Taxonomies.tags }}
- <li><a href="{{ "/tags/" | relLangURL }}{{ $name | urlize }}">{{ $name }}</a></li>
- {{ end }}
++```go-html-template
+<ul id="all-tags">
- <ul id="all-taxonomies">
- {{ range $taxonomyname, $taxonomy := .Site.Taxonomies }}
- <li><a href="{{ "/" | relLangURL}}{{ $taxonomyname | urlize }}">{{ $taxonomyname }}</a>
- <ul>
- {{ range $key, $value := $taxonomy }}
- <li> {{ $key }} </li>
- <ul>
- {{ range $value.Pages }}
- <li hugo-nav="{{ .RelPermalink}}"><a href="{{ .Permalink}}"> {{ .LinkTitle }} </a> </li>
- {{ end }}
- </ul>
- {{ end }}
- </ul>
- </li>
- {{ end }}
- </ul>
++ {{ range $name, $taxonomy := .Site.Taxonomies.tags }}
++ {{ with $.Site.GetPage (printf "/tags/%s" $name) }}
++ <li><a href="{{ .Permalink }}">{{ $name }}</a></li>
++ {{ end }}
++ {{ end }}
+</ul>
+```
+
+### Example: List All Taxonomies, Terms, and Assigned Content
+
+This example will list all taxonomies and their terms, as well as all the content assigned to each of the terms.
+
+{{< code file="layouts/partials/all-taxonomies.html" download="all-taxonomies.html" download="all-taxonomies.html" >}}
+<section>
- Because taxonomies are lists, the [`.GetPage` function][getpage] can be used to get all the pages associated with a particular taxonomy term using a terse syntax. The following ranges over the full list of tags on your site and links to each of the individual taxonomy pages for each term without having to use the more fragile URL construction of the "List All Site Tags" example above:
++ <ul id="all-taxonomies">
++ {{ range $taxonomy_term, $taxonomy := .Site.Taxonomies }}
++ {{ with $.Site.GetPage (printf "/%s" $taxonomy_term) }}
++ <li><a href="{{ .Permalink }}">{{ $taxonomy_term }}</a>
++ <ul>
++ {{ range $key, $value := $taxonomy }}
++ <li>{{ $key }}</li>
++ <ul>
++ {{ range $value.Pages }}
++ <li hugo-nav="{{ .RelPermalink}}">
++ <a href="{{ .Permalink}}">{{ .LinkTitle }}</a>
++ </li>
++ {{ end }}
++ </ul>
++ {{ end }}
++ </ul>
++ </li>
++ {{ end }}
++ {{ end }}
++ </ul>
+</section>
+{{< /code >}}
+
+## `.Site.GetPage` for Taxonomies
+
- {{< code file="links-to-all-tags" >}}
- <ul class="tags">
- {{ range ($.Site.GetPage "taxonomyTerm" "tags").Pages }}
- <li><a href="{{ .Permalink }}">{{ .Title}}</a></li>
- {{ end }}
++Because taxonomies are lists, the [`.GetPage` function][getpage] can be used to get all the pages associated with a particular taxonomy term using a terse syntax. The following ranges over the full list of tags on your site and links to each of the individual taxonomy pages for each term without having to use the more fragile URL construction of the ["List All Site Tags" example above]({{< relref "#example-list-all-site-tags" >}}):
+
- <!--### `.Site.GetPage` Taxonomy List Example
++{{< code file="links-to-all-tags.html" >}}
++{{ $taxo := "tags" }}
++<ul class="{{ $taxo }}">
++ {{ with ($.Site.GetPage (printf "/%s" $taxo)) }}
++ {{ range .Pages }}
++ <li><a href="{{ .Permalink }}">{{ .Title}}</a></li>
++ {{ end }}
++ {{ end }}
+</ul>
+{{< /code >}}
+
- ### `.Site.GetPage` Taxonomy Terms Example -->
++<!-- TODO: ### `.Site.GetPage` Taxonomy List Example -->
+
++<!-- TODO: ### `.Site.GetPage` Taxonomy Terms Example -->
+
+
+[delimit]: /functions/delimit/
+[getpage]: /functions/getpage/
+[lists]: /templates/lists/
+[renderlists]: /templates/lists/
+[single page template]: /templates/single-page-templates/
+[sitevars]: /variables/site/
--- /dev/null
+---
+title: Migrate to Hugo
+linktitle: Migrations
+description: A list of community-developed tools for migrating from your existing static site generator or content management system to Hugo.
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-02-01
+keywords: [migrations,jekyll,wordpress,drupal,ghost,contentful]
+menu:
+ docs:
+ parent: "tools"
+ weight: 10
+weight: 10
+sections_weight: 10
+draft: false
+aliases: [/developer-tools/migrations/,/developer-tools/migrated/]
+toc: true
+---
+
+This section highlights some projects around Hugo that are independently developed. These tools try to extend the functionality of our static site generator or help you to get started.
+
+{{% note %}}
+Do you know or maintain a similar project around Hugo? Feel free to open a [pull request](https://github.com/gohugoio/hugo/pulls) on GitHub if you think it should be added.
+{{% /note %}}
+
+Take a look at this list of migration tools if you currently use other blogging tools like Jekyll or WordPress but intend to switch to Hugo instead. They'll take care to export your content into Hugo-friendly formats.
+
+## Jekyll
+
+Alternatively, you can use the new [Jekyll import command](/commands/hugo_import_jekyll/).
+
+- [JekyllToHugo](https://github.com/SenjinDarashiva/JekyllToHugo) - A Small script for converting Jekyll blog posts to a Hugo site.
+- [ConvertToHugo](https://github.com/coderzh/ConvertToHugo) - Convert your blog from Jekyll to Hugo.
+
+## Ghost
+
+- [ghostToHugo](https://github.com/jbarone/ghostToHugo) - Convert Ghost blog posts and export them to Hugo.
+
+## Octopress
+
+- [octohug](https://github.com/codebrane/octohug) - Octopress to Hugo migrator.
+
+## DokuWiki
+
+- [dokuwiki-to-hugo](https://github.com/wgroeneveld/dokuwiki-to-hugo) - Migrates your dokuwiki source pages from [DokuWiki syntax](https://www.dokuwiki.org/wiki:syntax) to Hugo Markdown syntax. Includes extra's like the TODO plugin. Written with extensibility in mind using python 3. Also generates a TOML header for each page. Designed to copypaste the wiki directory into your /content directory.
+
+## WordPress
+
+- [wordpress-to-hugo-exporter](https://github.com/SchumacherFM/wordpress-to-hugo-exporter) - A one-click WordPress plugin that converts all posts, pages, taxonomies, metadata, and settings to Markdown and YAML which can be dropped into Hugo. (Note: If you have trouble using this plugin, you can [export your site for Jekyll](https://wordpress.org/plugins/jekyll-exporter/) and use Hugo's built in Jekyll converter listed above.)
++- [exitwp-for-hugo](https://github.com/wooni005/exitwp-for-hugo) - A python script which works with the xml export from Wordpress and converts Wordpress pages and posts to Markdown and YAML for hugo.
+- [blog2md](https://github.com/palaniraja/blog2md) - Works with [exported xml](https://en.support.wordpress.com/export/) file of your free YOUR-TLD.wordpress.com website. It also saves approved comments to `YOUR-POST-NAME-comments.md` file along with posts.
+
+## Tumblr
+
+- [tumblr-importr](https://github.com/carlmjohnson/tumblr-importr) - An importer that uses the Tumblr API to create a Hugo static site.
+- [tumblr2hugomarkdown](https://github.com/Wysie/tumblr2hugomarkdown) - Export all your Tumblr content to Hugo Markdown files with preserved original formatting.
+- [Tumblr to Hugo](https://github.com/jipiboily/tumblr-to-hugo) - A migration tool that converts each of your Tumblr posts to a content file with a proper title and path. Furthermore, "Tumblr to Hugo" creates a CSV file with the original URL and the new path on Hugo, to help you setup the redirections.
+
+## Drupal
+
+- [drupal2hugo](https://github.com/danapsimer/drupal2hugo) - Convert a Drupal site to Hugo.
+
+## Joomla
+
+- [hugojoomla](https://github.com/davetcc/hugojoomla) - This utility written in Java takes a Joomla database and converts all the content into Markdown files. It changes any URLs that are in Joomla's internal format and converts them to a suitable form.
+
+## Blogger
+
+- [blogimport](https://github.com/natefinch/blogimport) - A tool to import from Blogger posts to Hugo.
+- [blogger-to-hugo](https://bitbucket.org/petraszd/blogger-to-hugo) - Another tool to import Blogger posts to Hugo. It also downloads embedded images so they will be stored locally.
+- [blog2md](https://github.com/palaniraja/blog2md) - Works with [exported xml](https://support.google.com/blogger/answer/41387?hl=en) file of your YOUR-TLD.blogspot.com website. It also saves comments to `YOUR-POST-NAME-comments.md` file along with posts.
++- [BloggerToHugo](https://github.com/huanlin/blogger-to-hugo) - Yet another tool to import Blogger posts to Hugo. For Windows platform only, and .NET Framework 4.5 is required. See README.md before using this tool.
+
+## Contentful
+
+- [contentful2hugo](https://github.com/ArnoNuyts/contentful2hugo) - A tool to create content-files for Hugo from content on [Contentful](https://www.contentful.com/).
+
+
+## BlogML
+
+- [BlogML2Hugo](https://github.com/jijiechen/BlogML2Hugo) - A tool that helps you convert BlogML xml file to Hugo markdown files. Users need to take care of links to attachments and images by themselves. This helps the blogs that export BlogML files (e.g. BlogEngine.NET) tramsform to hugo sites easily.
--- /dev/null
- lastmod: 2017-02-22
+---
+title: Starter Kits
+linktitle: Starter Kits
+description: A list of community-developed projects designed to help you get up and running with Hugo.
+date: 2017-02-22
+publishdate: 2017-02-01
++lastmod: 2018-08-11
+keywords: [starters,assets,pipeline]
+menu:
+ docs:
+ parent: "tools"
+ weight: 30
+weight: 30
+sections_weight: 30
+draft: false
+aliases: [/developer-tools/migrations/,/developer-tools/migrated/]
+toc: false
+---
+
+Know of a Hugo-related starter kit that isn't mentioned here? [Please add it to the list.][addkit]
+
+{{% note "Starter Kits are Not Maintained by the Hugo Team"%}}
+The following starter kits are developed by active members of the Hugo community. If you find yourself having issues with any of the projects, it's best to file an issue directly with the project's maintainer(s).
+{{% /note %}}
+
++* [Hugo Wrapper][hugow]. Hugo Wrapper is a POSIX-style shell script which acts as a wrapper to download and run Hugo binary for your platform. It can be executed in variety of [Operating Systems][hugow-test] and [Command Shells][hugow-test].
+* [Victor Hugo][]. Victor Hugo is a Hugo boilerplate for creating truly epic websites using Gulp + Webpack as an asset pipeline. Victor Hugo uses post-css and Babel for CSS and JavaScript, respectively, and is actively maintained.
+* [GOHUGO AMP][]. GoHugo AMP is a starter theme that aims to make it easy to adopt [Google's AMP Project][amp]. The starter kit comes with 40+ shortcodes and partials plus automatic structured data. The project also includes a [separate site with extensive documentation][gohugodocs].
+* [Blaupause][]. Blaupause is a developer-friendly Hugo starter kit based on Gulp tasks. It comes ES6-ready with several helpers for SVG and fonts and basic structure for HTML, SCSS, and JavaScript.
+* [hugulp][]. hugulp is a tool to optimize the assets of a Hugo website. The main idea is to recreate the famous Ruby on Rails Asset Pipeline, which minifies, concatenates and fingerprints the assets used in your website.
+* [Atlas][]. Atlas is a Hugo boilerplate designed to speed up development with support for Netlify, Netlify CMS, Gulp, Linting, SCSS, ES6 & more. It's actively maintained and contributions are always welcome.
+
+
+[addkit]: https://github.com/gohugoio/hugo/edit/master/docs/content/en/tools/starter-kits.md
+[amp]: https://www.ampproject.org/
+[Blaupause]: https://github.com/fspoettel/blaupause
+[GOHUGO AMP]: https://github.com/wildhaber/gohugo-amp
+[gohugodocs]: https://gohugo-amp.gohugohq.com/
++[hugow]: https://github.com/khos2ow/hugo-wrapper
++[hugow-test]: https://github.com/khos2ow/hugo-wrapper#tested-on
+[hugulp]: https://github.com/jbrodriguez/hugulp
+[Victor Hugo]: https://github.com/netlify/victor-hugo
+[Atlas]: https://github.com/indigotree/atlas
--- /dev/null
- If the `.GitInfo` feature is enabled, **and** if the `lastmod` field in the content's front matter is not set, `.Lastmod` (on `Page`) is fetched from Git i.e. `.GitInfo.AuthorDate`.
+---
+title: Git Info Variables
+linktitle: Git Variables
+description: Get the last Git revision information for every content file.
+date: 2017-03-12
+publishdate: 2017-03-12
+lastmod: 2017-03-12
+categories: [variables and params]
+keywords: [git]
+draft: false
+menu:
+ docs:
+ parent: "variables"
+ weight: 70
+weight: 70
+sections_weight: 70
+aliases: [/extras/gitinfo/]
+toc: false
+wip: false
+---
+
+{{% note "`.GitInfo` Performance Considerations" %}}
+Hugo's Git integrations should be fairly performant but *can* increase your build time. This will depend on the size of your Git history.
+{{% /note %}}
+
+## `.GitInfo` Prerequisites
+
+1. The Hugo site must be in a Git-enabled directory.
+2. The Git executable must be installed and in your system `PATH`.
+3. The `.GitInfo` feature must be enabled in your Hugo project by passing `--enableGitInfo` flag on the command line or by setting `enableGitInfo` to `true` in your [site's configuration file][configuration].
+
+## The `.GitInfo` Object
+
+The `GitInfo` object contains the following fields:
+
+.AbbreviatedHash
+: the abbreviated commit hash (e.g., `866cbcc`)
+
+.AuthorName
+: the author's name, respecting `.mailmap`
+
+.AuthorEmail
+: the author's email address, respecting `.mailmap`
+
+.AuthorDate
+: the author date
+
+.Hash
+: the commit hash (e.g., `866cbccdab588b9908887ffd3b4f2667e94090c3`)
+
+.Subject
+: commit message subject (e.g., `tpl: Add custom index function`)
+
+## `.Lastmod`
+
++If the `.GitInfo` feature is enabled, `.Lastmod` (on `Page`) is fetched from Git i.e. `.GitInfo.AuthorDate`. This behaviour can be changed by adding your own [front matter configuration for dates](/getting-started/configuration/#configure-front-matter).
+
+[configuration]: /getting-started/configuration/
--- /dev/null
- url = "https://www.m0d3rnc0ad.com/post/static-site-firebase/"
+[[article]]
+ title = "A visit to the Workshop: Hugo/Unix/Vim integration"
+ url = "https://blog.afoolishmanifesto.com/posts/hugo-unix-vim-integration/"
+ author = "fREW Schmidt"
+ date = "2017-07-22"
+
+[[article]]
+ title = "Hugo Easy Gallery - Automagical PhotoSwipe image gallery with a one-line shortcode"
+ url = "https://www.liwen.id.au/heg/"
+ author = "Li-Wen Yip"
+ date = "2017-03-25"
+
+[[article]]
+ title = "Automagical Image Gallery in Hugo with PhotoSwipe and jQuery"
+ url = "https://www.liwen.id.au/photoswipe/"
+ author = "Li-Wen Yip"
+ date = "2017-03-04"
+
+[[article]]
+ title = "Adding Isso Comments to Hugo"
+ url = "https://stiobhart.net/2017-02-24-isso-comments/"
+ author = "Stíobhart Matulevicz"
+ date = "2017-02-24"
+
+[[article]]
+ title = "Hugo Tutorial: How to Build & Host a (Very Fast) Static E-Commerce Site"
+ url = "https://snipcart.com/blog/hugo-tutorial-static-site-ecommerce"
+ author = "Snipcart"
+ date = "2017-02-23"
+
+[[article]]
+ title = "How to Password Protect a Hugo Site"
+ url = "https://www.aerobatic.com/blog/password-protect-a-hugo-site/"
+ author = "Aerobatic"
+ date = "2017-02-19"
+
+[[article]]
+ title = "Switching from Wordpress to Hugo"
+ url = "http://schnuddelhuddel.de/switching-from-wordpress-to-hugo/"
+ author = "Mario Martelli"
+ date = "2017-02-19"
+
+[[article]]
+ title = "Zero to HTTP/2 with AWS and Hugo"
+ url = "https://habd.as/zero-to-http-2-aws-hugo/"
+ author = "Josh Habdas"
+ date = "2017-02-16"
+
+[[article]]
+ title = "Deploy a Hugo site to Aerobatic with CircleCI"
+ url = "https://www.aerobatic.com/blog/hugo-github-circleci/"
+ author = "Aerobatic"
+ date = "2017-02-14"
+
+[[article]]
+ title = "NPM scripts for building and deploying Hugo site"
+ url = "https://www.aerobatic.com/blog/hugo-npm-buildtool-setup/"
+ author = "Aerobatic"
+ date = "2017-02-12"
+
+[[article]]
+ title = "Getting started with Hugo and the plain-blog theme, on NearlyFreeSpeech.Net"
+ url = "https://www.penwatch.net/cms/get_started_plain_blog/"
+ author = "Li-aung “Lewis” Yip"
+ date = "2017-02-12"
+
+[[article]]
+ title = "Choose Hugo over Jekyll"
+ url = "https://habd.as/choose-hugo-over-jekyll/"
+ author = "Josh Habdas"
+ date = "2017-02-10"
+
+[[article]]
+ title = "Build a Hugo site using Cloud9 IDE and host on App Engine"
+ url = "https://loyall.ch/lab/2017/01/build-a-static-website-with-cloud9-hugo-and-app-engine/"
+ author = "Pascal Aubort"
+ date = "2017-02-05"
+
+[[article]]
+ title = "Hugo Continuous Deployment with Bitbucket Pipelines and Aerobatic"
+ url = "https://www.aerobatic.com/blog/hugo-bitbucket-pipelines/"
+ author = "Aerobatic"
+ date = "2017-02-04"
+
+[[article]]
+ title = "How to use Firebase to host a Hugo site"
++ url = "https://code.selfmadefighter.com/post/static-site-firebase/"
+ author = "Andrew Cuga"
+ date= "2017-02-04"
+
+[[article]]
+ title = "A publishing workflow for teams using static site generators"
+ url = "https://www.keybits.net/post/publishing-workflow-for-teams-using-static-site-generators/"
+ author = "Tom Atkins"
+ date = "2017-01-02"
+
+[[article]]
+ title = "How To Dynamically Use Google Fonts In A Hugo Website"
+ url = "https://stoned.io/web-development/hugo/How-To-Dynamically-Use-Google-Fonts-In-A-Hugo-Website/"
+ author = "Hash Borgir"
+ date = "2016-10-27"
+
+[[article]]
+ title = "Embedding Facebook In A Hugo Template"
+ url = "https://stoned.io/web-development/hugo/Embedding-Facebook-In-A-Hugo-Template/"
+ author = "Hash Borgir"
+ date = "2016-10-22"
+
+[[article]]
+ title = "通过 Gitlab-cl 将 Hugo blog 自动部署至 GitHub <small>(Chinese, Continuous integration)</small>"
+ url = "https://zetaoyang.github.io/post/2016/10/17/gitlab-cl.html"
+ author = "Zetao Yang"
+ date = "2016-10-17"
+
+[[article]]
+ title = "A Step-by-Step Guide: Hugo on Netlify"
+ url = "https://www.netlify.com/blog/2016/09/21/a-step-by-step-guide-hugo-on-netlify/"
+ author = "Eli Williamson"
+ date = "2016-09-21"
+
+[[article]]
+ title = "Building our site: From Django & Wordpress to a static generator (Part I)"
+ url = "https://tryolabs.com/blog/2016/09/20/building-our-site-django-wordpress-to-static-part-i/"
+ author = "Alan Descoins"
+ date = "2016-09-20"
+
+[[article]]
+ title = "Webseitenmaschine - Statische Websites mit Hugo erzeugen <small>(German, $)</small>"
+ url = "http://www.heise.de/ct/ausgabe/2016-12-Statische-Websites-mit-Hugo-erzeugen-3211704.html"
+ author = "Christian Helmbold"
+ date = "2016-05-27"
+
+[[article]]
+ title = "Cómo hacer sitios web estáticos con Hugo y Go - Platzi <small>(Video tutorial)</small>"
+ url = "https://www.youtube.com/watch?v=qaXXpdiCHXE"
+ author = "Verónica López"
+ date = "2016-04-06"
+
+[[article]]
+ title = "CDNOverview: A CDN comparison site made with Hugo"
+ url = "https://www.cloakfusion.com/cdnoverview-cdn-comparison-site-made-hugo/"
+ author = "Thijs de Zoete"
+ date = "2016-02-23"
+
+[[article]]
+ title = "Hugo: A Modern WebSite Engine That Just Works"
+ url = "https://github.com/shekhargulati/52-technologies-in-2016/blob/master/07-hugo/README.md"
+ author = "Shekhar Gulati"
+ date = "2016-02-14"
+
+[[article]]
+ title = "Minify Hugo Generated HTML"
+ url = "http://ratson.name/blog/minify-hugo-generated-html/"
+ author = "Ratson"
+ date = "2016-02-02"
+
+[[article]]
+ title = "<span lang='ja'>HugoのデプロイをWerckerからCircle CIに変更した</span> - log"
+ url = "http://log.deprode.net/logs/2016-01-17/"
+ author = "Deprode"
+ date = "2016-01-17"
+
+[[article]]
+ title = "Static site generators: el futuro de las webs estáticas<br>(Hugo, Jekyll, Flask y otros)"
+ url = "http://sitelabs.es/static-site-generators-futuro-las-webs-estaticas/"
+ author = "Eneko Sarasola"
+ date = "2016-01-09"
+
+[[article]]
+ title = "Writing a Lambda Function for Hugo"
+ url = "https://blog.jolexa.net/post/writing-a-lambda-function-for-hugo/"
+ author = "Jeremy Olexa"
+ date = "2016-01-01"
+
+[[article]]
+ title = "Ein Blog mit Hugo erstellen - Tutorial <small>(Deutsch/German)</small>"
+ url = "http://privat.albicker.org/tags/hugo.html"
+ author = "Bernhard Albicker"
+ date = "2015-12-30"
+
+[[article]]
+ title = "How to host Hugo static website generator on AWS Lambda"
+ url = "http://bezdelev.com/post/hugo-aws-lambda-static-website/"
+ author = "Ilya Bezdelev"
+ date = "2015-12-15"
+
+[[article]]
+ title = "Migrating from Pelican to Hugo"
+ url = "http://www.softinio.com/post/migrating-from-pelican-to-hugo/"
+ author = "Salar Rahmanian"
+ date = "2015-11-29"
+
+[[article]]
+ title = "Static Website Generators Reviewed: Jekyll, Middleman, Roots, Hugo"
+ url = "http://www.smashingmagazine.com/2015/11/static-website-generators-jekyll-middleman-roots-hugo-review/"
+ author = "Mathias Biilmann Christensen"
+ date = "2015-11-16"
+
+[[article]]
+ title = "How To Deploy a Hugo Site to Production with Git Hooks on Ubuntu 14.04"
+ url = "https://www.digitalocean.com/community/tutorials/how-to-deploy-a-hugo-site-to-production-with-git-hooks-on-ubuntu-14-04"
+ author = "Justin Ellingwood"
+ date = "2015-11-12"
+
+[[article]]
+ title = "How To Install and Use Hugo, a Static Site Generator, on Ubuntu 14.04"
+ url = "https://www.digitalocean.com/community/tutorials/how-to-install-and-use-hugo-a-static-site-generator-on-ubuntu-14-04"
+ author = "Justin Ellingwood"
+ date = "2015-11-09"
+
+[[article]]
+ title = "Switching from Wordpress to Hugo"
+ url = "http://justinfx.com/2015/11/08/switching-from-wordpress-to-hugo/"
+ author = "Justin Israel"
+ date = "2015-11-08"
+
+[[article]]
+ title = "Hands-on Experience with Hugo as a Static Site Generator"
+ url = "http://usersnap.com/blog/hands-on-experience-with-hugo-static-site-generator/"
+ author = "Thomas Peham"
+ date = "2015-10-15"
+
+[[article]]
+ title = "Statische Webseites mit Hugo erstellen/Vortrag mit Foliensatz (deutsch)"
+ url = "http://sfd.koelnerlinuxtreffen.de/2015/HaraldWeidner/"
+ author = "Harald Weidner"
+ date = "2015-09-19"
+
+[[article]]
+ title = "Moving from WordPress to Hugo"
+ url = "http://abhipandey.com/2015/09/moving-to-hugo/"
+ author = "Abhishek Pandey"
+ date = "2015-09-15"
+
+[[article]]
+ title = "<span lang='zh-CN'>通过webhook将Hugo自动部署至GitHub Pages和GitCafe Pages</span> <small>(Automated deployment)</small>"
+ url = "http://blog.coderzh.com/2015/09/13/use-webhook-automated-deploy-hugo/"
+ author = "CoderZh"
+ date = "2015-09-13"
+
+[[article]]
+ title = "<span lang='zh-CN'>使用hugo搭建个人博客站点</span> <small>(Using Hugo to build a personal blog site)</small>"
+ url = "http://blog.coderzh.com/2015/08/29/hugo/"
+ author = "CoderZh"
+ date = "2015-08-29"
+
+[[article]]
+ title = "Good-Bye Wordpress, Hello Hugo! <small>(German)</small>"
+ url = "http://blog.arminhanisch.de/2015/08/blog-migration-zu-hugo/"
+ author = "Armin Hanisch"
+ date = "2015-08-18"
+
+[[article]]
+ title = "Générer votre site web statique avec Hugo <small>(Generate your static site with Hugo)<small>"
+ url = "http://www.linux-pratique.com/?p=191"
+ author = "Benoît Benedetti"
+ date = "2015-06-26"
+
+[[article]]
+ title = "<span lang='ja'>Hugo向けの新しいテーマを作った</span> <small>(I created a new theme for Hugo)<small>"
+ url = "https://yet.unresolved.xyz/blog/2016/10/03/how-to-make-of-hugo-theme/"
+ author = "Daisuke Tsuji"
+ date = "2015-06-20"
+
+[[article]]
+ title = "Hugo - Gerando um site com conteúdo estático. (Portuguese Brazil)"
+ url = "http://blog.ffrizzo.com/posts/hugo/"
+ author = "Fabiano Frizzo"
+ date = "2015-06-02"
+
+[[article]]
+ title = "An Introduction to Static Site Generators"
+ url = "http://davidwalsh.name/introduction-static-site-generators"
+ author = "Eduardo Bouças"
+ date = "2015-05-20"
+
+[[article]]
+ title = "Hugo Still Rules"
+ url = "http://cheekycoder.com/2015/05/hugo-still-rules/"
+ author = "Cheeky Coder"
+ date = "2015-05-18"
+
+[[article]]
+ title = "hugo - Static Site Generator"
+ url = "http://gscacco.github.io/post/hugo/"
+ author = "G Scaccoio"
+ date = "2015-05-04"
+
+[[article]]
+ title = "<span lang='ja'>WindowsでHugoを使う</span>"
+ url = "http://ureta.net/2015/05/hugo-on-windows/"
+ author = "<span lang='ja'>うれ太郎</span>"
+ date = "2015-05-01"
+
+[[article]]
+ title = "<span lang='ja'>Hugoのshortcodesを用いてサイトにスライドなどを埋め込む</span>"
+ url = "http://blog.yucchiy.com/2015/04/29/hugo-shortcode/"
+ author = "Yucchiy"
+ date = "2015-04-29"
+
+[[article]]
+ title = "<span lang='ja'>HugoとCircleCIでGitHub PagesにBlogを公開してみたら超簡単だった</span>"
+ url = "http://hori-ryota.github.io/blog/create-blog-with-hugo-and-circleci/"
+ author = "Hori Ryota"
+ date = "2015-04-17"
+
+[[article]]
+ title = "10 Best Static Site Generators"
+ url = "http://beebom.com/2015/04/best-static-site-generators"
+ author = "Aniruddha Mysore"
+ date = "2015-04-06"
+
+[[article]]
+ title = "Goodbye WordPress; Hello Hugo"
+ url = "http://willwarren.com/2015/04/05/goodbye-wordpress-hello-hugo/"
+ author = "Will Warren"
+ date = "2015-04-05"
+
+[[article]]
+ title = "Static Websites with Hugo on Google Cloud Storage"
+ url = "http://www.moxie.io/post/static-websites-with-hugo-on-google-cloud-storage/"
+ author = "Moxie Input/Output"
+ date = "2015-04-02"
+
+[[article]]
+ title = "De nuevo iniciando un blog"
+ url = "https://alvarolizama.net/"
+ author = "Alvaro Lizama"
+ date = "2015-03-29"
+
+[[article]]
+ title = "We moved our blog from Posthaven to Hugo after only three posts. Why?"
+ url = "http://blog.hypriot.com/post/moved-from-posthaven-to-hugo/"
+ author = "Hypriot"
+ date = "2015-03-27"
+
+[[article]]
+ title = "Top Static Site Generators in 2015"
+ url = "http://superdevresources.com/static-site-generators-2015/"
+ author = "Kanishk Kunal"
+ date = "2015-03-12"
+
+[[article]]
+ title = "Moving to Hugo"
+ url = "http://abiosoft.com/moving-to-hugo/"
+ author = "Abiola Ibrahim"
+ date = "2015-03-08"
+
+[[article]]
+ title = "Migrating a blog (yes, this one!) from Wordpress to Hugo"
+ url = "http://justindunham.net/migrating-from-wordpress-to-hugo/"
+ author = "Justin Dunham"
+ date = "2015-02-13"
+
+[[article]]
+ title = "<span lang='ja'>blogをoctopressからHugoに乗り換えたメモ</span>"
+ url = "http://blog.jigyakkuma.org/2015/02/11/hugo/"
+ author = "jigyakkuma"
+ date = "2015-02-11"
+
+[[article]]
+ title = "<span lang='ja'>Hugoでブログをつくった</span>"
+ url = "http://porgy13.github.io/post/new-hugo-blog/"
+ author = "porgy13"
+ date = "2015-02-07"
+
+[[article]]
+ title = "<span lang='ja'>Hugoにブログを移行した</span>"
+ url = "http://keichi.net/post/first/"
+ author = "Keichi Takahashi"
+ date = "2015-02-04"
+
+[[article]]
+ title = "<span lang='zh-CN'>Hugo静态网站生成器中文教程</span>"
+ url = "http://nanshu.wang/post/2015-01-31/"
+ author = "Nanshu Wang"
+ date = "2015-01-31"
+
+[[article]]
+ title = "<span lang='ja'>Hugo + Github Pages + Wercker CI = ¥0（無料）<br>でコマンド 1 発（自動化）でサイト<br>・ブログを公開・運営・分析・収益化</span>"
+ url = "http://qiita.com/yoheimuta/items/8a619cac356bed89a4c9"
+ author = "Yohei Yoshimuta"
+ date = "2015-01-31"
+
+[[article]]
+ title = "Running Hugo websites on anynines"
+ url = "http://blog.anynines.com/running-hugo-websites-on-anynines/"
+ author = "Julian Weber"
+ date = "2015-01-30"
+
+[[article]]
+ title = "MiddlemanからHugoへ移行した"
+ url = "http://re-dzine.net/2015/01/hugo/"
+ author = "Haruki Konishi"
+ date = "2015-01-21"
+
+[[article]]
+ title = "WordPress から Hugo に乗り換えました"
+ url = "http://rakuishi.com/archives/wordpress-to-hugo/"
+ author = "rakuishi"
+ date = "2015-01-20"
+
+[[article]]
+ title = "HUGOを使ってサイトを立ち上げる方法"
+ url = "http://qiita.com/syui/items/869538099551f24acbbf"
+ author = "Syui"
+ date = "2015-01-17"
+
+[[article]]
+ title = "<span lang='ja'>Jekyllが許されるのは小学生までだよね</span>"
+ url = "http://t32k.me/mol/log/hugo/"
+ author = "Ishimoto Koji"
+ date = "2015-01-16"
+
+[[article]]
+ title = "Getting started with Hugo"
+ url = "http://anthonyfok.org/post/getting-started-with-hugo/"
+ author = "Anthony Fok"
+ date = "2015-01-12"
+
+[[article]]
+ title = "<span lang='zh-CN'>把这个博客静态化了</span> <small>(Migrate to Hugo)</small>"
+ url = "http://lich-eng.com/2015/01/03/migrate-to-hugo/"
+ author = "Li Cheng"
+ date = "2015-01-03"
+
+[[article]]
+ title = "Porting my blog with Hugo"
+ url = "http://blog.srackham.com/posts/porting-my-blog-with-hugo/"
+ author = "Stuart Rackham"
+ date = "2014-12-30"
+
+[[article]]
+ title = "Hugoを使ってみたときのメモ"
+ url = "http://machortz.github.io/posts/usinghugo/"
+ author = "Machortz"
+ date = "2014-12-29"
+
+[[article]]
+ title = "OctopressからHugoへ移行した"
+ url = "http://deeeet.com/writing/2014/12/25/hugo/"
+ author = "Taichi Nakashima"
+ date = "2014-12-25"
+
+[[article]]
+ title = "Migrating to Hugo From Octopress"
+ url = "http://nathanleclaire.com/blog/2014/12/22/migrating-to-hugo-from-octopress/"
+ author = "Nathan LeClaire"
+ date = "2014-12-22"
+
+[[article]]
+ title = "Dynamic Pages with GoHugo.io"
+ url = "http://cyrillschumacher.com/2014/12/21/dynamic-pages-with-gohugo.io/"
+ author = "Cyrill Schumacher"
+ date = "2014-12-21"
+
+[[article]]
+ title = "6 Static Blog Generators That Aren’t Jekyll"
+ url = "http://www.sitepoint.com/6-static-blog-generators-arent-jekyll/"
+ author = "David Turnbull"
+ date = "2014-12-08"
+
+[[article]]
+ title = "Travel Blogging Setup"
+ url = "http://www.stou.dk/2014/11/travel-blogging-setup/"
+ author = "Rasmus Stougaard"
+ date = "2014-11-23"
+
+[[article]]
+ title = "Hosting A Hugo Website Behind Nginx"
+ url = "http://www.bigbeeconsultants.co.uk/blog/hosting-hugo-website-behind-nginx"
+ author = "Rick Beton"
+ date = "2014-11-20"
+
+[[article]]
+ title = "<span lang='zh-CN'>使用Hugo搭建免费个人Blog</span> <small>(How to use Hugo)</small>"
+ url = "http://ulricqin.com/post/how-to-use-hugo/"
+ author = "Ulric Qin <span lang='zh-CN'>秦晓辉</span>"
+ date = "2014-11-11"
+
+[[article]]
+ title = "Built in Speed and Built for Speed by Hugo"
+ url = "http://cheekycoder.com/2014/10/built-for-speed-by-hugo/"
+ author = "Cheeky Coder"
+ date = "2014-10-30"
+
+[[article]]
+ title = "Hugo para crear sitios web estáticos"
+ url = "http://www.webbizarro.com/noticias/1076/hugo-para-crear-sitios-web-estaticos/"
+ author = "Web Bizarro"
+ date = "2014-08-19"
+
+[[article]]
+ title = "Going with hugo"
+ url = "http://www.markuseliasson.se/article/going-with-hugo/"
+ author = "Markus Eliasson"
+ date = "2014-08-18"
+
+[[article]]
+ title = "Benchmarking Jekyll, Hugo and Wintersmith"
+ url = "http://fredrikloch.me/post/2014-08-12-Jekyll-and-its-alternatives-from-a-site-generation-point-of-view/"
+ author = "Fredrik Loch"
+ date = "2014-08-12"
+
+[[article]]
+ title = "Goodbye Octopress, Hello Hugo!"
+ url = "http://andreimihu.com/blog/2014/08/11/goodbye-octopress-hello-hugo/"
+ author = "Andrei Mihu"
+ date = "2014-08-11"
+
+[[article]]
+ title = "Beautiful sites for Open Source projects"
+ url = "http://beautifulopen.com/2014/08/09/hugo/"
+ author = "Beautiful Open"
+ date = "2014-08-09"
+
+[[article]]
+ title = "Hugo: Beyond the Defaults"
+ url = "http://npf.io/2014/08/hugo-beyond-the-defaults/"
+ author = "Nate Finch"
+ date = "2014-08-08"
+
+[[article]]
+ title = "First Impressions of Hugo"
+ url = "https://peteraba.com/blog/first-impressions-of-hugo/"
+ author = "Peter Aba"
+ date = "2014-06-06"
+
+[[article]]
+ title = "New Site Workflow"
+ url = "http://vurt.co.uk/post/new_website/"
+ author = "Giles Paterson"
+ date = "2014-08-05"
+
+[[article]]
+ title = "How I Learned to Stop Worrying and Love the (Static) Web"
+ url = "http://cognition.ca/post/about-hugo/"
+ author = "Joshua McKenty"
+ date = "2014-08-04"
+
+[[article]]
+ title = "Hugo - Static Site Generator"
+ url = "http://kenwoo.io/blog/hugo---static-site-generator/"
+ author = "Kenny Woo"
+ date = "2014-08-03"
+
+[[article]]
+ title = "Hugo Is Friggin' Awesome"
+ url = "http://npf.io/2014/08/hugo-is-awesome/"
+ author = "Nate Finch"
+ date = "2014-08-01"
+
+[[article]]
+ title = "<span lang='zh-CN'>再次搬家</span> <small>(Move from WordPress to Hugo)</small>"
+ url = "http://www.chingli.com/misc/move-from-wordpress-to-hugo/"
+ author = "<span lang='zh-CN'>青砾</span> (chingli)"
+ date = "2014-07-12"
+
+[[article]]
+ title = "Embedding Gists in Hugo"
+ url = "http://danmux.com/posts/embedded_gists/"
+ author = "Dan Mull"
+ date = "2014-07-05"
+
+[[article]]
+ title = "An Introduction To Hugo"
+ url = "http://www.cirrushosting.com/web-hosting-blog/an-introduction-to-hugo/"
+ author = "Dan Silber"
+ date = "2014-07-01"
+
+[[article]]
+ title = "Moving to Hugo"
+ url = "http://danmux.com/posts/hugo_based_blog/"
+ author = "Dan Mull"
+ date = "2014-05-29"
+
+[[article]]
+ title = "<span lang='zh-CN'>开源之静态站点生成器排行榜</span><br><small>(Leaderboard of open-source static website generators)</small>"
+ url = "http://code.csdn.net/news/2819909"
+ author = "CSDN.net"
+ date = "2014-05-23"
+
+[[article]]
+ title = "Finally, a satisfying and effective blog setup"
+ url = "http://michaelwhatcott.com/now-powered-by-hugo/"
+ author = "Michael Whatcott"
+ date = "2014-05-20"
+
+[[article]]
+ title = "Hugo from scratch"
+ url = "http://zackofalltrades.com/notes/2014/05/hugo-from-scratch/"
+ author = "Zack Williams"
+ date = "2014-05-18"
+
+[[article]]
+ title = "Why I switched away from Jekyll"
+ url = "http://www.jakejanuzelli.com/why-I-switched-away-from-jekyll/"
+ author = "Jake Januzelli"
+ date = "2014-05-10"
+
+[[article]]
+ title = "Welcome our new blog"
+ url = "http://blog.ninya.io/posts/welcome-our-new-blog/"
+ author = "Ninya.io"
+ date = "2014-04-11"
+
+[[article]]
+ title = "Mission Not Accomplished"
+ url = "http://johnsto.co.uk/blog/mission-not-accomplished/"
+ author = "Dave Johnston"
+ date = "2014-04-03"
+
+[[article]]
+ title = "Hugo - A Static Site Builder in Go"
+ url = "http://deepfriedcode.com/post/hugo/"
+ author = "Deep Fried Code"
+ date = "2014-03-30"
+
+[[article]]
+ title = "Adventures in Angular Podcast"
+ url = "http://devchat.tv/adventures-in-angular/003-aia-gdes"
+ author = "Matias Niemela"
+ date = "2014-03-28"
+
+[[article]]
+ title = "Hugo"
+ url = "http://bra.am/post/hugo/"
+ author = "bra.am"
+ date = "2014-03-23"
+
+[[article]]
+ title = "Converting Blogger To Markdown"
+ url = "http://trishagee.github.io/project/atom-to-hugo/"
+ author = "Trisha Gee"
+ date = "2014-03-20"
+
+[[article]]
+ title = "Moving to Hugo Static Web Pages"
+ url = "http://tepid.org/tech/hugo-web/"
+ author = "Tobias Weingartner"
+ date = "2014-03-16"
+
+[[article]]
+ title = "New Blog Engine: Hugo"
+ url = "https://blog.afoolishmanifesto.com/posts/hugo/"
+ author = "fREW Schmidt"
+ date = "2014-03-15"
+
+[[article]]
+ title = "Hugo + gulp.js = Huggle"
+ url = "http://ktmud.github.io/huggle/en/intro/)"
+ author = "Jesse Yang <span lang='zh-CN'>杨建超</span>"
+ date = "2014-03-08"
+
+[[article]]
+ title = "Powered by Hugo"
+ url = "http://kieranhealy.org/blog/archives/2014/02/24/powered-by-hugo/"
+ author = "Kieran Healy"
+ date = "2014-02-24"
+
+[[article]]
+ title = "<span lang='ja'>静的サイトを素早く構築するために<br>GoLangで作られたジェネレータHugo</span>"
+ url = "http://hamasyou.com/blog/2014/02/21/hugo/"
+ author = "<div lang='ja' style='line-height: 1.1;'>Shogo Hamada<br>濱田章吾</div>"
+ date = "2014-02-21"
+
+[[article]]
+ title = "Latest Roundup of Useful Tools For Developers"
+ url = "http://codegeekz.com/latest-roundup-of-useful-tools-for-developers/"
+ author = "CodeGeekz"
+ date = "2014-02-13"
+
+[[article]]
+ title = "Hugo: Static Site Generator written in Go"
+ url = "http://www.braveterry.com/2014/02/06/hugo-static-site-generator-written-in-go/"
+ author = "Brave Terry"
+ date = "2014-02-06"
+
+[[article]]
+ title = "10 Useful HTML5 Tools for Web Designers and Developers"
+ url = "http://designdizzy.com/10-useful-html5-tools-for-web-designers-and-developers/"
+ author = "Design Dizzy"
+ date = "2014-02-04"
+
+[[article]]
+ title = "Hugo – Fast, Flexible Static Site Generator"
+ url = "http://cube3x.com/hugo-fast-flexible-static-site-generator/"
+ author = "Joby Joseph"
+ date = "2014-01-18"
+
+[[article]]
+ title = "Hugo: A new way to build static website"
+ url = "http://www.w3update.com/opensource/hugo-a-new-way-to-build-static-website.html"
+ author = "w3update"
+ date = "2014-01-17"
+
+[[article]]
+ title = "Xaprb now uses Hugo"
+ url = "http://xaprb.com/blog/2014/01/15/using-hugo/"
+ author = "Baron Schwartz"
+ date = "2014-01-15"
+
+[[article]]
+ title = "New jQuery Plugins And Resources That Web Designers Need"
+ url = "http://www.designyourway.net/blog/resources/new-jquery-plugins-and-resources-that-web-designers-need/"
+ author = "Design Your Way"
+ date = "2014-01-01"
+
+[[article]]
+ title = "On Blog Construction"
+ url = "http://alexla.sh/post/on-blog-construction/"
+ author = "Alexander Lash"
+ date = "2013-12-27"
+
+[[article]]
+ title = "Hugo"
+ url = "http://onethingwell.org/post/69070926608/hugo"
+ author = "One Thing Well"
+ date = "2013-12-05"
+
+[[article]]
+ title = "In Praise Of Hugo"
+ url = "http://sound-guru.com/blog/post/hello-world/"
+ author = "sound-guru.com"
+ date = "2013-10-19"
+
+[[article]]
+ title = "Hosting a blog on S3 and Cloudfront"
+ url = "http://www.danesparza.net/2013/07/hosting-a-blog-on-s3-and-cloudfront/"
+ author = "Dan Esparza"
+ date = "2013-07-24"
--- /dev/null
+{
+ "chroma": {
+ "lexers": [
+ {
+ "Name": "ABNF",
+ "Aliases": [
+ "abnf"
+ ]
+ },
+ {
+ "Name": "ANTLR",
+ "Aliases": [
+ "antlr"
+ ]
+ },
+ {
+ "Name": "APL",
+ "Aliases": [
+ "apl"
+ ]
+ },
+ {
+ "Name": "ActionScript",
+ "Aliases": [
+ "actionscript",
+ "as"
+ ]
+ },
+ {
+ "Name": "ActionScript 3",
+ "Aliases": [
+ "actionscript3",
+ "as",
+ "as3"
+ ]
+ },
+ {
+ "Name": "Ada",
+ "Aliases": [
+ "ada",
+ "ada2005",
+ "ada95",
+ "adb",
+ "ads"
+ ]
+ },
+ {
+ "Name": "Angular2",
+ "Aliases": [
+ "ng2"
+ ]
+ },
+ {
+ "Name": "ApacheConf",
+ "Aliases": [
+ "aconf",
+ "apache",
+ "apacheconf",
+ "conf",
+ "htaccess"
+ ]
+ },
+ {
+ "Name": "AppleScript",
+ "Aliases": [
+ "applescript"
+ ]
+ },
+ {
+ "Name": "Awk",
+ "Aliases": [
+ "awk",
+ "gawk",
+ "mawk",
+ "nawk"
+ ]
+ },
+ {
+ "Name": "BNF",
+ "Aliases": [
+ "bnf"
+ ]
+ },
+ {
+ "Name": "Base Makefile",
+ "Aliases": [
+ "*",
+ "bsdmake",
+ "mak",
+ "make",
+ "makefile",
+ "mf",
+ "mk"
+ ]
+ },
+ {
+ "Name": "Bash",
+ "Aliases": [
+ "bash",
+ "bash_*",
+ "bashrc",
+ "ebuild",
+ "eclass",
+ "exheres-0",
+ "exlib",
+ "ksh",
+ "sh",
+ "shell",
+ "zsh",
+ "zshrc"
+ ]
+ },
+ {
+ "Name": "Batchfile",
+ "Aliases": [
+ "bat",
+ "batch",
+ "cmd",
+ "dosbatch",
+ "winbatch"
+ ]
+ },
+ {
+ "Name": "BlitzBasic",
+ "Aliases": [
+ "b3d",
+ "bb",
+ "blitzbasic",
+ "bplus",
+ "decls"
+ ]
+ },
+ {
+ "Name": "Brainfuck",
+ "Aliases": [
+ "b",
+ "bf",
+ "brainfuck"
+ ]
+ },
+ {
+ "Name": "C",
+ "Aliases": [
+ "c",
+ "h",
+ "idc"
+ ]
+ },
+ {
+ "Name": "C#",
+ "Aliases": [
+ "c#",
+ "cs",
+ "csharp"
+ ]
+ },
+ {
+ "Name": "C++",
+ "Aliases": [
+ "C",
+ "CPP",
+ "H",
+ "c++",
+ "cc",
+ "cp",
+ "cpp",
+ "cxx",
+ "h++",
+ "hh",
+ "hpp",
+ "hxx"
+ ]
+ },
+ {
+ "Name": "CFEngine3",
+ "Aliases": [
+ "cf",
+ "cf3",
+ "cfengine3"
+ ]
+ },
+ {
+ "Name": "CMake",
+ "Aliases": [
+ "cmake",
+ "txt"
+ ]
+ },
+ {
+ "Name": "COBOL",
+ "Aliases": [
+ "COB",
+ "CPY",
+ "cob",
+ "cobol",
+ "cpy"
+ ]
+ },
+ {
+ "Name": "CSS",
+ "Aliases": [
+ "css"
+ ]
+ },
+ {
+ "Name": "Cap'n Proto",
+ "Aliases": [
+ "capnp"
+ ]
+ },
+ {
+ "Name": "Ceylon",
+ "Aliases": [
+ "ceylon"
+ ]
+ },
+ {
+ "Name": "ChaiScript",
+ "Aliases": [
+ "chai",
+ "chaiscript"
+ ]
+ },
+ {
+ "Name": "Cheetah",
+ "Aliases": [
+ "cheetah",
+ "spitfire",
+ "spt",
+ "tmpl"
+ ]
+ },
+ {
+ "Name": "Clojure",
+ "Aliases": [
+ "clj",
+ "clojure"
+ ]
+ },
+ {
+ "Name": "CoffeeScript",
+ "Aliases": [
+ "coffee",
+ "coffee-script",
+ "coffeescript"
+ ]
+ },
+ {
+ "Name": "Common Lisp",
+ "Aliases": [
+ "cl",
+ "common-lisp",
+ "lisp"
+ ]
+ },
+ {
+ "Name": "Coq",
+ "Aliases": [
+ "coq",
+ "v"
+ ]
+ },
+ {
+ "Name": "Crystal",
+ "Aliases": [
+ "cr",
+ "crystal"
+ ]
+ },
+ {
+ "Name": "Cython",
+ "Aliases": [
+ "cython",
+ "pxd",
+ "pxi",
+ "pyrex",
+ "pyx"
+ ]
+ },
+ {
+ "Name": "DTD",
+ "Aliases": [
+ "dtd"
+ ]
+ },
+ {
+ "Name": "Dart",
+ "Aliases": [
+ "dart"
+ ]
+ },
+ {
+ "Name": "Diff",
+ "Aliases": [
+ "diff",
+ "patch",
+ "udiff"
+ ]
+ },
+ {
+ "Name": "Django/Jinja",
+ "Aliases": [
+ "django",
+ "jinja"
+ ]
+ },
+ {
+ "Name": "Docker",
+ "Aliases": [
+ "docker",
+ "dockerfile"
+ ]
+ },
+ {
+ "Name": "EBNF",
+ "Aliases": [
+ "ebnf"
+ ]
+ },
+ {
+ "Name": "Elixir",
+ "Aliases": [
+ "elixir",
+ "ex",
+ "exs"
+ ]
+ },
+ {
+ "Name": "Elm",
+ "Aliases": [
+ "elm"
+ ]
+ },
+ {
+ "Name": "EmacsLisp",
+ "Aliases": [
+ "el",
+ "elisp",
+ "emacs",
+ "emacs-lisp"
+ ]
+ },
+ {
+ "Name": "Erlang",
+ "Aliases": [
+ "erl",
+ "erlang",
+ "es",
+ "escript",
+ "hrl"
+ ]
+ },
+ {
+ "Name": "FSharp",
+ "Aliases": [
+ "fs",
+ "fsharp",
+ "fsi"
+ ]
+ },
+ {
+ "Name": "Factor",
+ "Aliases": [
+ "factor"
+ ]
+ },
+ {
+ "Name": "Fish",
+ "Aliases": [
+ "fish",
+ "fishshell",
+ "load"
+ ]
+ },
+ {
+ "Name": "Forth",
+ "Aliases": [
+ "forth",
+ "frt",
+ "fs"
+ ]
+ },
+ {
+ "Name": "Fortran",
+ "Aliases": [
+ "F03",
+ "F90",
+ "f03",
+ "f90",
+ "fortran"
+ ]
+ },
+ {
+ "Name": "GAS",
+ "Aliases": [
+ "S",
+ "asm",
+ "gas",
+ "s"
+ ]
+ },
+ {
+ "Name": "GDScript",
+ "Aliases": [
+ "gd",
+ "gdscript"
+ ]
+ },
+ {
+ "Name": "GLSL",
+ "Aliases": [
+ "frag",
+ "geo",
+ "glsl",
+ "vert"
+ ]
+ },
+ {
+ "Name": "Genshi",
+ "Aliases": [
+ "genshi",
+ "kid",
+ "xml+genshi",
+ "xml+kid"
+ ]
+ },
+ {
+ "Name": "Genshi HTML",
+ "Aliases": [
+ "html+genshi",
+ "html+kid"
+ ]
+ },
+ {
+ "Name": "Genshi Text",
+ "Aliases": [
+ "genshitext"
+ ]
+ },
+ {
+ "Name": "Gnuplot",
+ "Aliases": [
+ "gnuplot",
+ "plot",
+ "plt"
+ ]
+ },
+ {
+ "Name": "Go",
+ "Aliases": [
+ "go",
+ "golang"
+ ]
+ },
+ {
+ "Name": "Go HTML Template",
+ "Aliases": [
+ "go-html-template"
+ ]
+ },
+ {
+ "Name": "Go Text Template",
+ "Aliases": [
+ "go-text-template"
+ ]
+ },
+ {
+ "Name": "Groovy",
+ "Aliases": [
+ "gradle",
+ "groovy"
+ ]
+ },
+ {
+ "Name": "HTML",
+ "Aliases": [
+ "htm",
+ "html",
+ "xhtml",
+ "xslt"
+ ]
+ },
+ {
+ "Name": "HTTP",
+ "Aliases": [
+ "http"
+ ]
+ },
+ {
+ "Name": "Handlebars",
+ "Aliases": [
+ "handlebars"
+ ]
+ },
+ {
+ "Name": "Haskell",
+ "Aliases": [
+ "haskell",
+ "hs"
+ ]
+ },
+ {
+ "Name": "Haxe",
+ "Aliases": [
+ "haxe",
+ "hx",
+ "hxsl"
+ ]
+ },
+ {
+ "Name": "Hexdump",
+ "Aliases": [
+ "hexdump"
+ ]
+ },
+ {
+ "Name": "Hy",
+ "Aliases": [
+ "hy",
+ "hylang"
+ ]
+ },
+ {
+ "Name": "INI",
+ "Aliases": [
+ "cfg",
+ "dosini",
+ "inf",
+ "ini"
+ ]
+ },
+ {
+ "Name": "Idris",
+ "Aliases": [
+ "idr",
+ "idris"
+ ]
+ },
+ {
+ "Name": "Io",
+ "Aliases": [
+ "io"
+ ]
+ },
+ {
+ "Name": "JSON",
+ "Aliases": [
+ "json"
+ ]
+ },
+ {
+ "Name": "JSX",
+ "Aliases": [
+ "jsx",
+ "react"
+ ]
+ },
+ {
+ "Name": "Java",
+ "Aliases": [
+ "java"
+ ]
+ },
+ {
+ "Name": "JavaScript",
+ "Aliases": [
+ "javascript",
+ "js",
+ "jsm"
+ ]
+ },
+ {
+ "Name": "Julia",
+ "Aliases": [
+ "jl",
+ "julia"
+ ]
+ },
+ {
+ "Name": "Kotlin",
+ "Aliases": [
+ "kotlin",
+ "kt"
+ ]
+ },
+ {
+ "Name": "LLVM",
+ "Aliases": [
+ "ll",
+ "llvm"
+ ]
+ },
+ {
+ "Name": "Lighttpd configuration file",
+ "Aliases": [
+ "lighttpd",
+ "lighty"
+ ]
+ },
+ {
+ "Name": "Lua",
+ "Aliases": [
+ "lua",
+ "wlua"
+ ]
+ },
+ {
+ "Name": "Mako",
+ "Aliases": [
+ "mako",
+ "mao"
+ ]
+ },
+ {
+ "Name": "Mason",
+ "Aliases": [
+ "m",
+ "mason",
+ "mc",
+ "mhtml",
+ "mi"
+ ]
+ },
+ {
+ "Name": "Mathematica",
+ "Aliases": [
+ "cdf",
+ "ma",
+ "mathematica",
+ "mma",
+ "nb",
+ "nbp"
+ ]
+ },
+ {
+ "Name": "MiniZinc",
+ "Aliases": [
+ "MZN",
+ "dzn",
+ "fzn",
+ "minizinc",
+ "mzn"
+ ]
+ },
+ {
+ "Name": "Modula-2",
+ "Aliases": [
+ "def",
+ "m2",
+ "mod",
+ "modula2"
+ ]
+ },
+ {
+ "Name": "MorrowindScript",
+ "Aliases": [
+ "morrowind",
+ "mwscript"
+ ]
+ },
+ {
+ "Name": "MySQL",
+ "Aliases": [
+ "mysql",
+ "sql"
+ ]
+ },
+ {
+ "Name": "Myghty",
+ "Aliases": [
+ "myghty",
+ "myt"
+ ]
+ },
+ {
+ "Name": "NASM",
+ "Aliases": [
+ "ASM",
+ "asm",
+ "nasm"
+ ]
+ },
+ {
+ "Name": "Newspeak",
+ "Aliases": [
+ "newspeak",
+ "ns2"
+ ]
+ },
+ {
+ "Name": "Nginx configuration file",
+ "Aliases": [
+ "conf",
+ "nginx"
+ ]
+ },
+ {
+ "Name": "Nim",
+ "Aliases": [
+ "nim",
+ "nimrod"
+ ]
+ },
+ {
+ "Name": "Nix",
+ "Aliases": [
+ "nix",
+ "nixos"
+ ]
+ },
+ {
+ "Name": "OCaml",
+ "Aliases": [
+ "ml",
+ "mli",
+ "mll",
+ "mly",
+ "ocaml"
+ ]
+ },
+ {
+ "Name": "Objective-C",
+ "Aliases": [
+ "h",
+ "m",
+ "obj-c",
+ "objc",
+ "objective-c",
+ "objectivec"
+ ]
+ },
+ {
+ "Name": "Octave",
+ "Aliases": [
+ "m",
+ "octave"
+ ]
+ },
+ {
+ "Name": "PHP",
+ "Aliases": [
+ "inc",
+ "php",
+ "php3",
+ "php4",
+ "php5",
+ "php[345]"
+ ]
+ },
+ {
+ "Name": "PL/pgSQL",
+ "Aliases": [
+ "plpgsql"
+ ]
+ },
+ {
+ "Name": "POVRay",
+ "Aliases": [
+ "inc",
+ "pov"
+ ]
+ },
+ {
+ "Name": "PacmanConf",
+ "Aliases": [
+ "conf",
+ "pacmanconf"
+ ]
+ },
+ {
+ "Name": "Perl",
+ "Aliases": [
+ "perl",
+ "pl",
+ "pm",
+ "t"
+ ]
+ },
+ {
+ "Name": "Pig",
+ "Aliases": [
+ "pig"
+ ]
+ },
+ {
+ "Name": "PkgConfig",
+ "Aliases": [
+ "pc",
+ "pkgconfig"
+ ]
+ },
+ {
+ "Name": "PostScript",
+ "Aliases": [
+ "eps",
+ "postscr",
+ "postscript",
+ "ps"
+ ]
+ },
+ {
+ "Name": "PostgreSQL SQL dialect",
+ "Aliases": [
+ "postgres",
+ "postgresql"
+ ]
+ },
+ {
+ "Name": "PowerShell",
+ "Aliases": [
+ "posh",
+ "powershell",
+ "ps1",
+ "psm1"
+ ]
+ },
+ {
+ "Name": "Prolog",
+ "Aliases": [
+ "ecl",
+ "pl",
+ "pro",
+ "prolog"
+ ]
+ },
+ {
+ "Name": "Protocol Buffer",
+ "Aliases": [
+ "proto",
+ "protobuf"
+ ]
+ },
+ {
+ "Name": "Puppet",
+ "Aliases": [
+ "pp",
+ "puppet"
+ ]
+ },
+ {
+ "Name": "Python",
+ "Aliases": [
+ "py",
+ "python",
+ "pyw",
+ "sage",
+ "sc",
+ "tac"
+ ]
+ },
+ {
+ "Name": "Python 3",
+ "Aliases": [
+ "py3",
+ "python3"
+ ]
+ },
+ {
+ "Name": "QBasic",
+ "Aliases": [
+ "BAS",
+ "bas",
+ "basic",
+ "qbasic"
+ ]
+ },
+ {
+ "Name": "R",
+ "Aliases": [
+ "R",
+ "Renviron",
+ "Rhistory",
+ "Rprofile",
+ "S",
+ "r",
+ "s",
+ "splus"
+ ]
+ },
+ {
+ "Name": "Racket",
+ "Aliases": [
+ "racket",
+ "rkt",
+ "rktd",
+ "rktl"
+ ]
+ },
+ {
+ "Name": "Ragel",
+ "Aliases": [
+ "ragel"
+ ]
+ },
+ {
+ "Name": "Rexx",
+ "Aliases": [
+ "arexx",
+ "rex",
+ "rexx",
+ "rx"
+ ]
+ },
+ {
+ "Name": "Ruby",
+ "Aliases": [
+ "duby",
+ "gemspec",
+ "rake",
+ "rb",
+ "rbw",
+ "rbx",
+ "ruby"
+ ]
+ },
+ {
+ "Name": "Rust",
+ "Aliases": [
+ "in",
+ "rs",
+ "rust"
+ ]
+ },
+ {
+ "Name": "SCSS",
+ "Aliases": [
+ "scss"
+ ]
+ },
+ {
+ "Name": "SPARQL",
+ "Aliases": [
+ "rq",
+ "sparql"
+ ]
+ },
+ {
+ "Name": "SQL",
+ "Aliases": [
+ "sql"
+ ]
+ },
+ {
+ "Name": "Sass",
+ "Aliases": [
+ "sass"
+ ]
+ },
+ {
+ "Name": "Scala",
+ "Aliases": [
+ "scala"
+ ]
+ },
+ {
+ "Name": "Scheme",
+ "Aliases": [
+ "scheme",
+ "scm",
+ "ss"
+ ]
+ },
+ {
+ "Name": "Scilab",
+ "Aliases": [
+ "sce",
+ "sci",
+ "scilab",
+ "tst"
+ ]
+ },
+ {
+ "Name": "Smalltalk",
+ "Aliases": [
+ "smalltalk",
+ "squeak",
+ "st"
+ ]
+ },
+ {
+ "Name": "Smarty",
+ "Aliases": [
+ "smarty",
+ "tpl"
+ ]
+ },
+ {
+ "Name": "Snobol",
+ "Aliases": [
+ "snobol"
+ ]
+ },
+ {
+ "Name": "Solidity",
+ "Aliases": [
+ "sol",
+ "solidity"
+ ]
+ },
+ {
+ "Name": "SquidConf",
+ "Aliases": [
+ "conf",
+ "squid",
+ "squid.conf",
+ "squidconf"
+ ]
+ },
+ {
+ "Name": "Swift",
+ "Aliases": [
+ "swift"
+ ]
+ },
+ {
+ "Name": "TASM",
+ "Aliases": [
+ "ASM",
+ "asm",
+ "tasm"
+ ]
+ },
+ {
+ "Name": "TOML",
+ "Aliases": [
+ "toml"
+ ]
+ },
+ {
+ "Name": "Tcl",
+ "Aliases": [
+ "rvt",
+ "tcl"
+ ]
+ },
+ {
+ "Name": "Tcsh",
+ "Aliases": [
+ "csh",
+ "tcsh"
+ ]
+ },
+ {
+ "Name": "TeX",
+ "Aliases": [
+ "aux",
+ "latex",
+ "tex",
+ "toc"
+ ]
+ },
+ {
+ "Name": "Termcap",
+ "Aliases": [
+ "src",
+ "termcap"
+ ]
+ },
+ {
+ "Name": "Terminfo",
+ "Aliases": [
+ "src",
+ "terminfo"
+ ]
+ },
+ {
+ "Name": "Terraform",
+ "Aliases": [
+ "terraform",
+ "tf"
+ ]
+ },
+ {
+ "Name": "Thrift",
+ "Aliases": [
+ "thrift"
+ ]
+ },
+ {
+ "Name": "Transact-SQL",
+ "Aliases": [
+ "t-sql",
+ "tsql"
+ ]
+ },
+ {
+ "Name": "Turtle",
+ "Aliases": [
+ "ttl",
+ "turtle"
+ ]
+ },
+ {
+ "Name": "Twig",
+ "Aliases": [
+ "twig"
+ ]
+ },
+ {
+ "Name": "TypeScript",
+ "Aliases": [
+ "ts",
+ "tsx",
+ "typescript"
+ ]
+ },
+ {
+ "Name": "TypoScript",
+ "Aliases": [
+ "ts",
+ "txt",
+ "typoscript"
+ ]
+ },
+ {
+ "Name": "TypoScriptCssData",
+ "Aliases": [
+ "typoscriptcssdata"
+ ]
+ },
+ {
+ "Name": "TypoScriptHtmlData",
+ "Aliases": [
+ "typoscripthtmldata"
+ ]
+ },
+ {
+ "Name": "VHDL",
+ "Aliases": [
+ "vhd",
+ "vhdl"
+ ]
+ },
+ {
+ "Name": "VimL",
+ "Aliases": [
+ "exrc",
+ "gvimrc",
+ "vim",
+ "vimrc"
+ ]
+ },
+ {
+ "Name": "WDTE",
+ "Aliases": [
+ "wdte"
+ ]
+ },
+ {
+ "Name": "XML",
+ "Aliases": [
+ "rss",
+ "svg",
+ "wsdl",
+ "wsf",
+ "xml",
+ "xsd",
+ "xsl",
+ "xslt"
+ ]
+ },
+ {
+ "Name": "Xorg",
+ "Aliases": [
+ "conf",
+ "xorg.conf"
+ ]
+ },
+ {
+ "Name": "YAML",
+ "Aliases": [
+ "yaml",
+ "yml"
+ ]
+ },
+ {
+ "Name": "cfstatement",
+ "Aliases": [
+ "cfs"
+ ]
+ },
+ {
+ "Name": "markdown",
+ "Aliases": [
+ "markdown",
+ "md",
+ "mkd"
+ ]
+ },
+ {
+ "Name": "plaintext",
+ "Aliases": [
+ "no-highlight",
+ "plain",
+ "text",
+ "txt"
+ ]
+ },
+ {
+ "Name": "reStructuredText",
+ "Aliases": [
+ "rest",
+ "restructuredtext",
+ "rst"
+ ]
+ },
+ {
+ "Name": "reg",
+ "Aliases": [
+ "reg",
+ "registry"
+ ]
+ },
+ {
+ "Name": "systemverilog",
+ "Aliases": [
+ "sv",
+ "svh",
+ "systemverilog"
+ ]
+ },
+ {
+ "Name": "verilog",
+ "Aliases": [
+ "v",
+ "verilog"
+ ]
+ }
+ ]
+ },
+ "media": {
+ "types": [
+ {
+ "type": "application/javascript",
+ "string": "application/javascript+js",
+ "mainType": "application",
+ "subType": "javascript",
+ "suffix": "js",
+ "delimiter": "."
+ },
+ {
+ "type": "application/json",
+ "string": "application/json+json",
+ "mainType": "application",
+ "subType": "json",
+ "suffix": "json",
+ "delimiter": "."
+ },
+ {
+ "type": "application/rss",
+ "string": "application/rss+xml",
+ "mainType": "application",
+ "subType": "rss",
+ "suffix": "xml",
+ "delimiter": "."
+ },
+ {
+ "type": "application/xml",
+ "string": "application/xml+xml",
+ "mainType": "application",
+ "subType": "xml",
+ "suffix": "xml",
+ "delimiter": "."
+ },
+ {
+ "type": "text/calendar",
+ "string": "text/calendar+ics",
+ "mainType": "text",
+ "subType": "calendar",
+ "suffix": "ics",
+ "delimiter": "."
+ },
+ {
+ "type": "text/css",
+ "string": "text/css+css",
+ "mainType": "text",
+ "subType": "css",
+ "suffix": "css",
+ "delimiter": "."
+ },
+ {
+ "type": "text/csv",
+ "string": "text/csv+csv",
+ "mainType": "text",
+ "subType": "csv",
+ "suffix": "csv",
+ "delimiter": "."
+ },
+ {
+ "type": "text/html",
+ "string": "text/html+html",
+ "mainType": "text",
+ "subType": "html",
+ "suffix": "html",
+ "delimiter": "."
+ },
+ {
+ "type": "text/plain",
+ "string": "text/plain+txt",
+ "mainType": "text",
+ "subType": "plain",
+ "suffix": "txt",
+ "delimiter": "."
+ }
+ ]
+ },
+ "output": {
+ "formats": [
+ {
+ "MediaType": "text/html+html",
+ "name": "AMP",
+ "mediaType": {
+ "type": "text/html",
+ "string": "text/html+html",
+ "mainType": "text",
+ "subType": "html",
+ "suffix": "html",
+ "delimiter": "."
+ },
+ "path": "amp",
+ "baseName": "index",
+ "rel": "amphtml",
+ "protocol": "",
+ "isPlainText": false,
+ "isHTML": true,
+ "noUgly": false,
+ "notAlternative": false
+ },
+ {
+ "MediaType": "text/css+css",
+ "name": "CSS",
+ "mediaType": {
+ "type": "text/css",
+ "string": "text/css+css",
+ "mainType": "text",
+ "subType": "css",
+ "suffix": "css",
+ "delimiter": "."
+ },
+ "path": "",
+ "baseName": "styles",
+ "rel": "stylesheet",
+ "protocol": "",
+ "isPlainText": true,
+ "isHTML": false,
+ "noUgly": false,
+ "notAlternative": true
+ },
+ {
+ "MediaType": "text/csv+csv",
+ "name": "CSV",
+ "mediaType": {
+ "type": "text/csv",
+ "string": "text/csv+csv",
+ "mainType": "text",
+ "subType": "csv",
+ "suffix": "csv",
+ "delimiter": "."
+ },
+ "path": "",
+ "baseName": "index",
+ "rel": "alternate",
+ "protocol": "",
+ "isPlainText": true,
+ "isHTML": false,
+ "noUgly": false,
+ "notAlternative": false
+ },
+ {
+ "MediaType": "text/calendar+ics",
+ "name": "Calendar",
+ "mediaType": {
+ "type": "text/calendar",
+ "string": "text/calendar+ics",
+ "mainType": "text",
+ "subType": "calendar",
+ "suffix": "ics",
+ "delimiter": "."
+ },
+ "path": "",
+ "baseName": "index",
+ "rel": "alternate",
+ "protocol": "webcal://",
+ "isPlainText": true,
+ "isHTML": false,
+ "noUgly": false,
+ "notAlternative": false
+ },
+ {
+ "MediaType": "text/html+html",
+ "name": "HTML",
+ "mediaType": {
+ "type": "text/html",
+ "string": "text/html+html",
+ "mainType": "text",
+ "subType": "html",
+ "suffix": "html",
+ "delimiter": "."
+ },
+ "path": "",
+ "baseName": "index",
+ "rel": "canonical",
+ "protocol": "",
+ "isPlainText": false,
+ "isHTML": true,
+ "noUgly": false,
+ "notAlternative": false
+ },
+ {
+ "MediaType": "application/json+json",
+ "name": "JSON",
+ "mediaType": {
+ "type": "application/json",
+ "string": "application/json+json",
+ "mainType": "application",
+ "subType": "json",
+ "suffix": "json",
+ "delimiter": "."
+ },
+ "path": "",
+ "baseName": "index",
+ "rel": "alternate",
+ "protocol": "",
+ "isPlainText": true,
+ "isHTML": false,
+ "noUgly": false,
+ "notAlternative": false
+ },
+ {
+ "MediaType": "text/plain+txt",
+ "name": "ROBOTS",
+ "mediaType": {
+ "type": "text/plain",
+ "string": "text/plain+txt",
+ "mainType": "text",
+ "subType": "plain",
+ "suffix": "txt",
+ "delimiter": "."
+ },
+ "path": "",
+ "baseName": "robots",
+ "rel": "alternate",
+ "protocol": "",
+ "isPlainText": true,
+ "isHTML": false,
+ "noUgly": false,
+ "notAlternative": false
+ },
+ {
+ "MediaType": "application/rss+xml",
+ "name": "RSS",
+ "mediaType": {
+ "type": "application/rss",
+ "string": "application/rss+xml",
+ "mainType": "application",
+ "subType": "rss",
+ "suffix": "xml",
+ "delimiter": "."
+ },
+ "path": "",
+ "baseName": "index",
+ "rel": "alternate",
+ "protocol": "",
+ "isPlainText": false,
+ "isHTML": false,
+ "noUgly": true,
+ "notAlternative": false
+ },
+ {
+ "MediaType": "application/xml+xml",
+ "name": "Sitemap",
+ "mediaType": {
+ "type": "application/xml",
+ "string": "application/xml+xml",
+ "mainType": "application",
+ "subType": "xml",
+ "suffix": "xml",
+ "delimiter": "."
+ },
+ "path": "",
+ "baseName": "sitemap",
+ "rel": "sitemap",
+ "protocol": "",
+ "isPlainText": false,
+ "isHTML": false,
+ "noUgly": true,
+ "notAlternative": false
+ }
+ ],
+ "layouts": [
+ {
+ "Example": "Single page in \"posts\" section",
+ "Kind": "page",
+ "OutputFormat": "HTML",
+ "Suffix": "html",
+ "Template Lookup Order": [
+ "layouts/posts/single.html.html",
+ "layouts/posts/single.html",
+ "layouts/_default/single.html.html",
+ "layouts/_default/single.html"
+ ]
+ },
+ {
+ "Example": "Single page in \"posts\" section with layout set",
+ "Kind": "page",
+ "OutputFormat": "HTML",
+ "Suffix": "html",
+ "Template Lookup Order": [
+ "layouts/posts/demolayout.html.html",
+ "layouts/posts/single.html.html",
+ "layouts/posts/demolayout.html",
+ "layouts/posts/single.html",
+ "layouts/_default/demolayout.html.html",
+ "layouts/_default/single.html.html",
+ "layouts/_default/demolayout.html",
+ "layouts/_default/single.html"
+ ]
+ },
+ {
+ "Example": "AMP single page",
+ "Kind": "page",
+ "OutputFormat": "AMP",
+ "Suffix": "html",
+ "Template Lookup Order": [
+ "layouts/posts/single.amp.html",
+ "layouts/posts/single.html",
+ "layouts/_default/single.amp.html",
+ "layouts/_default/single.html"
+ ]
+ },
+ {
+ "Example": "AMP single page, French language",
+ "Kind": "page",
+ "OutputFormat": "AMP",
+ "Suffix": "html",
+ "Template Lookup Order": [
+ "layouts/posts/single.fr.amp.html",
+ "layouts/posts/single.amp.html",
+ "layouts/posts/single.fr.html",
+ "layouts/posts/single.html",
+ "layouts/_default/single.fr.amp.html",
+ "layouts/_default/single.amp.html",
+ "layouts/_default/single.fr.html",
+ "layouts/_default/single.html"
+ ]
+ },
+ {
+ "Example": "Home page",
+ "Kind": "home",
+ "OutputFormat": "HTML",
+ "Suffix": "html",
+ "Template Lookup Order": [
+ "layouts/index.html.html",
+ "layouts/home.html.html",
+ "layouts/list.html.html",
+ "layouts/index.html",
+ "layouts/home.html",
+ "layouts/list.html",
+ "layouts/_default/index.html.html",
+ "layouts/_default/home.html.html",
+ "layouts/_default/list.html.html",
+ "layouts/_default/index.html",
+ "layouts/_default/home.html",
+ "layouts/_default/list.html"
+ ]
+ },
+ {
+ "Example": "Home page with type set",
+ "Kind": "home",
+ "OutputFormat": "HTML",
+ "Suffix": "html",
+ "Template Lookup Order": [
+ "layouts/demotype/index.html.html",
+ "layouts/demotype/home.html.html",
+ "layouts/demotype/list.html.html",
+ "layouts/demotype/index.html",
+ "layouts/demotype/home.html",
+ "layouts/demotype/list.html",
+ "layouts/index.html.html",
+ "layouts/home.html.html",
+ "layouts/list.html.html",
+ "layouts/index.html",
+ "layouts/home.html",
+ "layouts/list.html",
+ "layouts/_default/index.html.html",
+ "layouts/_default/home.html.html",
+ "layouts/_default/list.html.html",
+ "layouts/_default/index.html",
+ "layouts/_default/home.html",
+ "layouts/_default/list.html"
+ ]
+ },
+ {
+ "Example": "Home page with layout set",
+ "Kind": "home",
+ "OutputFormat": "HTML",
+ "Suffix": "html",
+ "Template Lookup Order": [
+ "layouts/demolayout.html.html",
+ "layouts/index.html.html",
+ "layouts/home.html.html",
+ "layouts/list.html.html",
+ "layouts/demolayout.html",
+ "layouts/index.html",
+ "layouts/home.html",
+ "layouts/list.html",
+ "layouts/_default/demolayout.html.html",
+ "layouts/_default/index.html.html",
+ "layouts/_default/home.html.html",
+ "layouts/_default/list.html.html",
+ "layouts/_default/demolayout.html",
+ "layouts/_default/index.html",
+ "layouts/_default/home.html",
+ "layouts/_default/list.html"
+ ]
+ },
+ {
+ "Example": "AMP home, French language\"",
+ "Kind": "home",
+ "OutputFormat": "AMP",
+ "Suffix": "html",
+ "Template Lookup Order": [
+ "layouts/index.fr.amp.html",
+ "layouts/home.fr.amp.html",
+ "layouts/list.fr.amp.html",
+ "layouts/index.amp.html",
+ "layouts/home.amp.html",
+ "layouts/list.amp.html",
+ "layouts/index.fr.html",
+ "layouts/home.fr.html",
+ "layouts/list.fr.html",
+ "layouts/index.html",
+ "layouts/home.html",
+ "layouts/list.html",
+ "layouts/_default/index.fr.amp.html",
+ "layouts/_default/home.fr.amp.html",
+ "layouts/_default/list.fr.amp.html",
+ "layouts/_default/index.amp.html",
+ "layouts/_default/home.amp.html",
+ "layouts/_default/list.amp.html",
+ "layouts/_default/index.fr.html",
+ "layouts/_default/home.fr.html",
+ "layouts/_default/list.fr.html",
+ "layouts/_default/index.html",
+ "layouts/_default/home.html",
+ "layouts/_default/list.html"
+ ]
+ },
+ {
+ "Example": "JSON home",
+ "Kind": "home",
+ "OutputFormat": "JSON",
+ "Suffix": "json",
+ "Template Lookup Order": [
+ "layouts/index.json.json",
+ "layouts/home.json.json",
+ "layouts/list.json.json",
+ "layouts/index.json",
+ "layouts/home.json",
+ "layouts/list.json",
+ "layouts/_default/index.json.json",
+ "layouts/_default/home.json.json",
+ "layouts/_default/list.json.json",
+ "layouts/_default/index.json",
+ "layouts/_default/home.json",
+ "layouts/_default/list.json"
+ ]
+ },
+ {
+ "Example": "RSS home",
+ "Kind": "home",
+ "OutputFormat": "RSS",
+ "Suffix": "xml",
+ "Template Lookup Order": [
+ "layouts/index.rss.xml",
+ "layouts/home.rss.xml",
+ "layouts/rss.xml",
+ "layouts/list.rss.xml",
+ "layouts/index.xml",
+ "layouts/home.xml",
+ "layouts/list.xml",
+ "layouts/_default/index.rss.xml",
+ "layouts/_default/home.rss.xml",
+ "layouts/_default/rss.xml",
+ "layouts/_default/list.rss.xml",
+ "layouts/_default/index.xml",
+ "layouts/_default/home.xml",
+ "layouts/_default/list.xml",
+ "layouts/_internal/_default/rss.xml"
+ ]
+ },
+ {
+ "Example": "RSS section posts",
+ "Kind": "section",
+ "OutputFormat": "RSS",
+ "Suffix": "xml",
+ "Template Lookup Order": [
+ "layouts/posts/section.rss.xml",
+ "layouts/posts/rss.xml",
+ "layouts/posts/list.rss.xml",
+ "layouts/posts/section.xml",
+ "layouts/posts/list.xml",
+ "layouts/section/section.rss.xml",
+ "layouts/section/rss.xml",
+ "layouts/section/list.rss.xml",
+ "layouts/section/section.xml",
+ "layouts/section/list.xml",
+ "layouts/_default/section.rss.xml",
+ "layouts/_default/rss.xml",
+ "layouts/_default/list.rss.xml",
+ "layouts/_default/section.xml",
+ "layouts/_default/list.xml",
+ "layouts/_internal/_default/rss.xml"
+ ]
+ },
+ {
+ "Example": "Taxonomy list in categories",
+ "Kind": "taxonomy",
+ "OutputFormat": "RSS",
+ "Suffix": "xml",
+ "Template Lookup Order": [
+ "layouts/categories/category.rss.xml",
+ "layouts/categories/taxonomy.rss.xml",
+ "layouts/categories/rss.xml",
+ "layouts/categories/list.rss.xml",
+ "layouts/categories/category.xml",
+ "layouts/categories/taxonomy.xml",
+ "layouts/categories/list.xml",
+ "layouts/taxonomy/category.rss.xml",
+ "layouts/taxonomy/taxonomy.rss.xml",
+ "layouts/taxonomy/rss.xml",
+ "layouts/taxonomy/list.rss.xml",
+ "layouts/taxonomy/category.xml",
+ "layouts/taxonomy/taxonomy.xml",
+ "layouts/taxonomy/list.xml",
+ "layouts/category/category.rss.xml",
+ "layouts/category/taxonomy.rss.xml",
+ "layouts/category/rss.xml",
+ "layouts/category/list.rss.xml",
+ "layouts/category/category.xml",
+ "layouts/category/taxonomy.xml",
+ "layouts/category/list.xml",
+ "layouts/_default/category.rss.xml",
+ "layouts/_default/taxonomy.rss.xml",
+ "layouts/_default/rss.xml",
+ "layouts/_default/list.rss.xml",
+ "layouts/_default/category.xml",
+ "layouts/_default/taxonomy.xml",
+ "layouts/_default/list.xml",
+ "layouts/_internal/_default/rss.xml"
+ ]
+ },
+ {
+ "Example": "Taxonomy terms in categories",
+ "Kind": "taxonomyTerm",
+ "OutputFormat": "RSS",
+ "Suffix": "xml",
+ "Template Lookup Order": [
+ "layouts/categories/category.terms.rss.xml",
+ "layouts/categories/terms.rss.xml",
+ "layouts/categories/rss.xml",
+ "layouts/categories/list.rss.xml",
+ "layouts/categories/category.terms.xml",
+ "layouts/categories/terms.xml",
+ "layouts/categories/list.xml",
+ "layouts/taxonomy/category.terms.rss.xml",
+ "layouts/taxonomy/terms.rss.xml",
+ "layouts/taxonomy/rss.xml",
+ "layouts/taxonomy/list.rss.xml",
+ "layouts/taxonomy/category.terms.xml",
+ "layouts/taxonomy/terms.xml",
+ "layouts/taxonomy/list.xml",
+ "layouts/category/category.terms.rss.xml",
+ "layouts/category/terms.rss.xml",
+ "layouts/category/rss.xml",
+ "layouts/category/list.rss.xml",
+ "layouts/category/category.terms.xml",
+ "layouts/category/terms.xml",
+ "layouts/category/list.xml",
+ "layouts/_default/category.terms.rss.xml",
+ "layouts/_default/terms.rss.xml",
+ "layouts/_default/rss.xml",
+ "layouts/_default/list.rss.xml",
+ "layouts/_default/category.terms.xml",
+ "layouts/_default/terms.xml",
+ "layouts/_default/list.xml",
+ "layouts/_internal/_default/rss.xml"
+ ]
+ },
+ {
+ "Example": "Section list for \"posts\" section",
+ "Kind": "section",
+ "OutputFormat": "HTML",
+ "Suffix": "html",
+ "Template Lookup Order": [
+ "layouts/posts/posts.html.html",
+ "layouts/posts/section.html.html",
+ "layouts/posts/list.html.html",
+ "layouts/posts/posts.html",
+ "layouts/posts/section.html",
+ "layouts/posts/list.html",
+ "layouts/section/posts.html.html",
+ "layouts/section/section.html.html",
+ "layouts/section/list.html.html",
+ "layouts/section/posts.html",
+ "layouts/section/section.html",
+ "layouts/section/list.html",
+ "layouts/_default/posts.html.html",
+ "layouts/_default/section.html.html",
+ "layouts/_default/list.html.html",
+ "layouts/_default/posts.html",
+ "layouts/_default/section.html",
+ "layouts/_default/list.html"
+ ]
+ },
+ {
+ "Example": "Section list for \"posts\" section with type set to \"blog\"",
+ "Kind": "section",
+ "OutputFormat": "HTML",
+ "Suffix": "html",
+ "Template Lookup Order": [
+ "layouts/blog/posts.html.html",
+ "layouts/blog/section.html.html",
+ "layouts/blog/list.html.html",
+ "layouts/blog/posts.html",
+ "layouts/blog/section.html",
+ "layouts/blog/list.html",
+ "layouts/posts/posts.html.html",
+ "layouts/posts/section.html.html",
+ "layouts/posts/list.html.html",
+ "layouts/posts/posts.html",
+ "layouts/posts/section.html",
+ "layouts/posts/list.html",
+ "layouts/section/posts.html.html",
+ "layouts/section/section.html.html",
+ "layouts/section/list.html.html",
+ "layouts/section/posts.html",
+ "layouts/section/section.html",
+ "layouts/section/list.html",
+ "layouts/_default/posts.html.html",
+ "layouts/_default/section.html.html",
+ "layouts/_default/list.html.html",
+ "layouts/_default/posts.html",
+ "layouts/_default/section.html",
+ "layouts/_default/list.html"
+ ]
+ },
+ {
+ "Example": "Section list for \"posts\" section with layout set to \"demoLayout\"",
+ "Kind": "section",
+ "OutputFormat": "HTML",
+ "Suffix": "html",
+ "Template Lookup Order": [
+ "layouts/posts/demolayout.html.html",
+ "layouts/posts/posts.html.html",
+ "layouts/posts/section.html.html",
+ "layouts/posts/list.html.html",
+ "layouts/posts/demolayout.html",
+ "layouts/posts/posts.html",
+ "layouts/posts/section.html",
+ "layouts/posts/list.html",
+ "layouts/section/demolayout.html.html",
+ "layouts/section/posts.html.html",
+ "layouts/section/section.html.html",
+ "layouts/section/list.html.html",
+ "layouts/section/demolayout.html",
+ "layouts/section/posts.html",
+ "layouts/section/section.html",
+ "layouts/section/list.html",
+ "layouts/_default/demolayout.html.html",
+ "layouts/_default/posts.html.html",
+ "layouts/_default/section.html.html",
+ "layouts/_default/list.html.html",
+ "layouts/_default/demolayout.html",
+ "layouts/_default/posts.html",
+ "layouts/_default/section.html",
+ "layouts/_default/list.html"
+ ]
+ },
+ {
+ "Example": "Taxonomy list in categories",
+ "Kind": "taxonomy",
+ "OutputFormat": "HTML",
+ "Suffix": "html",
+ "Template Lookup Order": [
+ "layouts/categories/category.html.html",
+ "layouts/categories/taxonomy.html.html",
+ "layouts/categories/list.html.html",
+ "layouts/categories/category.html",
+ "layouts/categories/taxonomy.html",
+ "layouts/categories/list.html",
+ "layouts/taxonomy/category.html.html",
+ "layouts/taxonomy/taxonomy.html.html",
+ "layouts/taxonomy/list.html.html",
+ "layouts/taxonomy/category.html",
+ "layouts/taxonomy/taxonomy.html",
+ "layouts/taxonomy/list.html",
+ "layouts/category/category.html.html",
+ "layouts/category/taxonomy.html.html",
+ "layouts/category/list.html.html",
+ "layouts/category/category.html",
+ "layouts/category/taxonomy.html",
+ "layouts/category/list.html",
+ "layouts/_default/category.html.html",
+ "layouts/_default/taxonomy.html.html",
+ "layouts/_default/list.html.html",
+ "layouts/_default/category.html",
+ "layouts/_default/taxonomy.html",
+ "layouts/_default/list.html"
+ ]
+ },
+ {
+ "Example": "Taxonomy term in categories",
+ "Kind": "taxonomyTerm",
+ "OutputFormat": "HTML",
+ "Suffix": "html",
+ "Template Lookup Order": [
+ "layouts/categories/category.terms.html.html",
+ "layouts/categories/terms.html.html",
+ "layouts/categories/list.html.html",
+ "layouts/categories/category.terms.html",
+ "layouts/categories/terms.html",
+ "layouts/categories/list.html",
+ "layouts/taxonomy/category.terms.html.html",
+ "layouts/taxonomy/terms.html.html",
+ "layouts/taxonomy/list.html.html",
+ "layouts/taxonomy/category.terms.html",
+ "layouts/taxonomy/terms.html",
+ "layouts/taxonomy/list.html",
+ "layouts/category/category.terms.html.html",
+ "layouts/category/terms.html.html",
+ "layouts/category/list.html.html",
+ "layouts/category/category.terms.html",
+ "layouts/category/terms.html",
+ "layouts/category/list.html",
+ "layouts/_default/category.terms.html.html",
+ "layouts/_default/terms.html.html",
+ "layouts/_default/list.html.html",
+ "layouts/_default/category.terms.html",
+ "layouts/_default/terms.html",
+ "layouts/_default/list.html"
+ ]
+ }
+ ]
+ },
+ "tpl": {
+ "funcs": {
+ "cast": {
+ "ToFloat": {
+ "Description": "ToFloat converts the given value to a float.",
+ "Args": [
+ "v"
+ ],
+ "Aliases": [
+ "float"
+ ],
+ "Examples": [
+ [
+ "{{ \"1234\" | float | printf \"%T\" }}",
+ "float64"
+ ]
+ ]
+ },
+ "ToInt": {
+ "Description": "ToInt converts the given value to an int.",
+ "Args": [
+ "v"
+ ],
+ "Aliases": [
+ "int"
+ ],
+ "Examples": [
+ [
+ "{{ \"1234\" | int | printf \"%T\" }}",
+ "int"
+ ]
+ ]
+ },
+ "ToString": {
+ "Description": "ToString converts the given value to a string.",
+ "Args": [
+ "v"
+ ],
+ "Aliases": [
+ "string"
+ ],
+ "Examples": [
+ [
+ "{{ 1234 | string | printf \"%T\" }}",
+ "string"
+ ]
+ ]
+ }
+ },
+ "compare": {
+ "Conditional": {
+ "Description": "Conditional can be used as a ternary operator.\nIt returns a if condition, else b.",
+ "Args": [
+ "condition",
+ "a",
+ "b"
+ ],
+ "Aliases": [
+ "cond"
+ ],
+ "Examples": [
+ [
+ "{{ cond (eq (add 2 2) 4) \"2+2 is 4\" \"what?\" | safeHTML }}",
+ "2+2 is 4"
+ ]
+ ]
+ },
+ "Default": {
+ "Description": "Default checks whether a given value is set and returns a default value if it\nis not. \"Set\" in this context means non-zero for numeric types and times;\nnon-zero length for strings, arrays, slices, and maps;\nany boolean or struct value; or non-nil for any other types.",
+ "Args": [
+ "dflt",
+ "given"
+ ],
+ "Aliases": [
+ "default"
+ ],
+ "Examples": [
+ [
+ "{{ \"Hugo Rocks!\" | default \"Hugo Rules!\" }}",
+ "Hugo Rocks!"
+ ],
+ [
+ "{{ \"\" | default \"Hugo Rules!\" }}",
+ "Hugo Rules!"
+ ]
+ ]
+ },
+ "Eq": {
+ "Description": "Eq returns the boolean truth of arg1 == arg2.",
+ "Args": [
+ "x",
+ "y"
+ ],
+ "Aliases": [
+ "eq"
+ ],
+ "Examples": [
+ [
+ "{{ if eq .Section \"blog\" }}current{{ end }}",
+ "current"
+ ]
+ ]
+ },
+ "Ge": {
+ "Description": "Ge returns the boolean truth of arg1 \u003e= arg2.",
+ "Args": [
+ "a",
+ "b"
+ ],
+ "Aliases": [
+ "ge"
+ ],
+ "Examples": [
+ [
+ "{{ if ge .Hugo.Version \"0.36\" }}Reasonable new Hugo version!{{ end }}",
+ "Reasonable new Hugo version!"
+ ]
+ ]
+ },
+ "Gt": {
+ "Description": "Gt returns the boolean truth of arg1 \u003e arg2.",
+ "Args": [
+ "a",
+ "b"
+ ],
+ "Aliases": [
+ "gt"
+ ],
+ "Examples": []
+ },
+ "Le": {
+ "Description": "Le returns the boolean truth of arg1 \u003c= arg2.",
+ "Args": [
+ "a",
+ "b"
+ ],
+ "Aliases": [
+ "le"
+ ],
+ "Examples": []
+ },
+ "Lt": {
+ "Description": "Lt returns the boolean truth of arg1 \u003c arg2.",
+ "Args": [
+ "a",
+ "b"
+ ],
+ "Aliases": [
+ "lt"
+ ],
+ "Examples": []
+ },
+ "Ne": {
+ "Description": "Ne returns the boolean truth of arg1 != arg2.",
+ "Args": [
+ "x",
+ "y"
+ ],
+ "Aliases": [
+ "ne"
+ ],
+ "Examples": []
+ }
+ },
+ "collections": {
+ "After": {
+ "Description": "After returns all the items after the first N in a rangeable list.",
+ "Args": [
+ "index",
+ "seq"
+ ],
+ "Aliases": [
+ "after"
+ ],
+ "Examples": []
+ },
+ "Apply": {
+ "Description": "Apply takes a map, array, or slice and returns a new slice with the function fname applied over it.",
+ "Args": [
+ "seq",
+ "fname",
+ "args"
+ ],
+ "Aliases": [
+ "apply"
+ ],
+ "Examples": []
+ },
+ "Delimit": {
+ "Description": "Delimit takes a given sequence and returns a delimited HTML string.\nIf last is passed to the function, it will be used as the final delimiter.",
+ "Args": [
+ "seq",
+ "delimiter",
+ "last"
+ ],
+ "Aliases": [
+ "delimit"
+ ],
+ "Examples": [
+ [
+ "{{ delimit (slice \"A\" \"B\" \"C\") \", \" \" and \" }}",
+ "A, B and C"
+ ]
+ ]
+ },
+ "Dictionary": {
+ "Description": "Dictionary creates a map[string]interface{} from the given parameters by\nwalking the parameters and treating them as key-value pairs. The number\nof parameters must be even.",
+ "Args": [
+ "values"
+ ],
+ "Aliases": [
+ "dict"
+ ],
+ "Examples": []
+ },
+ "EchoParam": {
+ "Description": "EchoParam returns a given value if it is set; otherwise, it returns an\nempty string.",
+ "Args": [
+ "a",
+ "key"
+ ],
+ "Aliases": [
+ "echoParam"
+ ],
+ "Examples": [
+ [
+ "{{ echoParam .Params \"langCode\" }}",
+ "en"
+ ]
+ ]
+ },
+ "First": {
+ "Description": "First returns the first N items in a rangeable list.",
+ "Args": [
+ "limit",
+ "seq"
+ ],
+ "Aliases": [
+ "first"
+ ],
+ "Examples": []
+ },
+ "In": {
+ "Description": "In returns whether v is in the set l. l may be an array or slice.",
+ "Args": [
+ "l",
+ "v"
+ ],
+ "Aliases": [
+ "in"
+ ],
+ "Examples": [
+ [
+ "{{ if in \"this string contains a substring\" \"substring\" }}Substring found!{{ end }}",
+ "Substring found!"
+ ]
+ ]
+ },
+ "Index": {
+ "Description": "Index returns the result of indexing its first argument by the following\narguments. Thus \"index x 1 2 3\" is, in Go syntax, x[1][2][3]. Each\nindexed item must be a map, slice, or array.\n\nCopied from Go stdlib src/text/template/funcs.go.\n\nWe deviate from the stdlib due to https://github.com/golang/go/issues/14751.\n\nTODO(moorereason): merge upstream changes.",
+ "Args": [
+ "item",
+ "indices"
+ ],
+ "Aliases": [
+ "index"
+ ],
+ "Examples": []
+ },
+ "Intersect": {
+ "Description": "Intersect returns the common elements in the given sets, l1 and l2. l1 and\nl2 must be of the same type and may be either arrays or slices.",
+ "Args": [
+ "l1",
+ "l2"
+ ],
+ "Aliases": [
+ "intersect"
+ ],
+ "Examples": []
+ },
+ "IsSet": {
+ "Description": "IsSet returns whether a given array, channel, slice, or map has a key\ndefined.",
+ "Args": [
+ "a",
+ "key"
+ ],
+ "Aliases": [
+ "isSet",
+ "isset"
+ ],
+ "Examples": []
+ },
+ "KeyVals": {
+ "Description": "KeyVals creates a key and values wrapper.",
+ "Args": [
+ "key",
+ "vals"
+ ],
+ "Aliases": [
+ "keyVals"
+ ],
+ "Examples": [
+ [
+ "{{ keyVals \"key\" \"a\" \"b\" }}",
+ "key: [a b]"
+ ]
+ ]
+ },
+ "Last": {
+ "Description": "Last returns the last N items in a rangeable list.",
+ "Args": [
+ "limit",
+ "seq"
+ ],
+ "Aliases": [
+ "last"
+ ],
+ "Examples": []
+ },
+ "Querify": {
+ "Description": "Querify encodes the given parameters in URL-encoded form (\"bar=baz\u0026foo=quux\") sorted by key.",
+ "Args": [
+ "params"
+ ],
+ "Aliases": [
+ "querify"
+ ],
+ "Examples": [
+ [
+ "{{ (querify \"foo\" 1 \"bar\" 2 \"baz\" \"with spaces\" \"qux\" \"this\u0026that=those\") | safeHTML }}",
+ "bar=2\u0026baz=with+spaces\u0026foo=1\u0026qux=this%26that%3Dthose"
+ ],
+ [
+ "\u003ca href=\"https://www.google.com?{{ (querify \"q\" \"test\" \"page\" 3) | safeURL }}\"\u003eSearch\u003c/a\u003e",
+ "\u003ca href=\"https://www.google.com?page=3\u0026amp;q=test\"\u003eSearch\u003c/a\u003e"
+ ]
+ ]
+ },
+ "Seq": {
+ "Description": "Seq creates a sequence of integers. It's named and used as GNU's seq.\n\nExamples:\n 3 =\u003e 1, 2, 3\n 1 2 4 =\u003e 1, 3\n -3 =\u003e -1, -2, -3\n 1 4 =\u003e 1, 2, 3, 4\n 1 -2 =\u003e 1, 0, -1, -2",
+ "Args": [
+ "args"
+ ],
+ "Aliases": [
+ "seq"
+ ],
+ "Examples": [
+ [
+ "{{ seq 3 }}",
+ "[1 2 3]"
+ ]
+ ]
+ },
+ "Shuffle": {
+ "Description": "Shuffle returns the given rangeable list in a randomised order.",
+ "Args": [
+ "seq"
+ ],
+ "Aliases": [
+ "shuffle"
+ ],
+ "Examples": []
+ },
+ "Slice": {
+ "Description": "Slice returns a slice of all passed arguments.",
+ "Args": [
+ "args"
+ ],
+ "Aliases": [
+ "slice"
+ ],
+ "Examples": [
+ [
+ "{{ slice \"B\" \"C\" \"A\" | sort }}",
+ "[A B C]"
+ ]
+ ]
+ },
+ "Sort": {
+ "Description": "Sort returns a sorted sequence.",
+ "Args": [
+ "seq",
+ "args"
+ ],
+ "Aliases": [
+ "sort"
+ ],
+ "Examples": []
+ },
+ "Union": {
+ "Description": "Union returns the union of the given sets, l1 and l2. l1 and\nl2 must be of the same type and may be either arrays or slices.\nIf l1 and l2 aren't of the same type then l1 will be returned.\nIf either l1 or l2 is nil then the non-nil list will be returned.",
+ "Args": [
+ "l1",
+ "l2"
+ ],
+ "Aliases": [
+ "union"
+ ],
+ "Examples": [
+ [
+ "{{ union (slice 1 2 3) (slice 3 4 5) }}",
+ "[1 2 3 4 5]"
+ ]
+ ]
+ },
+ "Uniq": {
+ "Description": "Uniq takes in a slice or array and returns a slice with subsequent\nduplicate elements removed.",
+ "Args": [
+ "l"
+ ],
+ "Aliases": [
+ "uniq"
+ ],
+ "Examples": [
+ [
+ "{{ slice 1 2 3 2 | uniq }}",
+ "[1 2 3]"
+ ]
+ ]
+ },
+ "Where": {
+ "Description": "Where returns a filtered subset of a given data type.",
+ "Args": [
+ "seq",
+ "key",
+ "args"
+ ],
+ "Aliases": [
+ "where"
+ ],
+ "Examples": []
+ }
+ },
+ "crypto": {
+ "MD5": {
+ "Description": "MD5 hashes the given input and returns its MD5 checksum.",
+ "Args": [
+ "in"
+ ],
+ "Aliases": [
+ "md5"
+ ],
+ "Examples": [
+ [
+ "{{ md5 \"Hello world, gophers!\" }}",
+ "b3029f756f98f79e7f1b7f1d1f0dd53b"
+ ],
+ [
+ "{{ crypto.MD5 \"Hello world, gophers!\" }}",
+ "b3029f756f98f79e7f1b7f1d1f0dd53b"
+ ]
+ ]
+ },
+ "SHA1": {
+ "Description": "SHA1 hashes the given input and returns its SHA1 checksum.",
+ "Args": [
+ "in"
+ ],
+ "Aliases": [
+ "sha1"
+ ],
+ "Examples": [
+ [
+ "{{ sha1 \"Hello world, gophers!\" }}",
+ "c8b5b0e33d408246e30f53e32b8f7627a7a649d4"
+ ]
+ ]
+ },
+ "SHA256": {
+ "Description": "SHA256 hashes the given input and returns its SHA256 checksum.",
+ "Args": [
+ "in"
+ ],
+ "Aliases": [
+ "sha256"
+ ],
+ "Examples": [
+ [
+ "{{ sha256 \"Hello world, gophers!\" }}",
+ "6ec43b78da9669f50e4e422575c54bf87536954ccd58280219c393f2ce352b46"
+ ]
+ ]
+ }
+ },
+ "data": {
+ "GetCSV": {
+ "Description": "GetCSV expects a data separator and one or n-parts of a URL to a resource which\ncan either be a local or a remote one.\nThe data separator can be a comma, semi-colon, pipe, etc, but only one character.\nIf you provide multiple parts for the URL they will be joined together to the final URL.\nGetCSV returns nil or a slice slice to use in a short code.",
+ "Args": [
+ "sep",
+ "urlParts"
+ ],
+ "Aliases": [
+ "getCSV"
+ ],
+ "Examples": []
+ },
+ "GetJSON": {
+ "Description": "GetJSON expects one or n-parts of a URL to a resource which can either be a local or a remote one.\nIf you provide multiple parts they will be joined together to the final URL.\nGetJSON returns nil or parsed JSON to use in a short code.",
+ "Args": [
+ "urlParts"
+ ],
+ "Aliases": [
+ "getJSON"
+ ],
+ "Examples": []
+ }
+ },
+ "encoding": {
+ "Base64Decode": {
+ "Description": "Base64Decode returns the base64 decoding of the given content.",
+ "Args": [
+ "content"
+ ],
+ "Aliases": [
+ "base64Decode"
+ ],
+ "Examples": [
+ [
+ "{{ \"SGVsbG8gd29ybGQ=\" | base64Decode }}",
+ "Hello world"
+ ],
+ [
+ "{{ 42 | base64Encode | base64Decode }}",
+ "42"
+ ]
+ ]
+ },
+ "Base64Encode": {
+ "Description": "Base64Encode returns the base64 encoding of the given content.",
+ "Args": [
+ "content"
+ ],
+ "Aliases": [
+ "base64Encode"
+ ],
+ "Examples": [
+ [
+ "{{ \"Hello world\" | base64Encode }}",
+ "SGVsbG8gd29ybGQ="
+ ]
+ ]
+ },
+ "Jsonify": {
+ "Description": "Jsonify encodes a given object to JSON.",
+ "Args": [
+ "v"
+ ],
+ "Aliases": [
+ "jsonify"
+ ],
+ "Examples": [
+ [
+ "{{ (slice \"A\" \"B\" \"C\") | jsonify }}",
+ "[\"A\",\"B\",\"C\"]"
+ ]
+ ]
+ }
+ },
+ "fmt": {
+ "Errorf": {
+ "Description": "",
+ "Args": [
+ "format",
+ "a"
+ ],
+ "Aliases": [
+ "errorf"
+ ],
+ "Examples": [
+ [
+ "{{ errorf \"%s.\" \"failed\" }}",
+ "failed."
+ ]
+ ]
+ },
+ "Print": {
+ "Description": "Print returns string representation of the passed arguments.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "print"
+ ],
+ "Examples": [
+ [
+ "{{ print \"works!\" }}",
+ "works!"
+ ]
+ ]
+ },
+ "Printf": {
+ "Description": "Printf returns a formatted string representation of the passed arguments.",
+ "Args": [
+ "format",
+ "a"
+ ],
+ "Aliases": [
+ "printf"
+ ],
+ "Examples": [
+ [
+ "{{ printf \"%s!\" \"works\" }}",
+ "works!"
+ ]
+ ]
+ },
+ "Println": {
+ "Description": "Println returns string representation of the passed arguments ending with a newline.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "println"
+ ],
+ "Examples": [
+ [
+ "{{ println \"works!\" }}",
+ "works!\n"
+ ]
+ ]
+ }
+ },
+ "images": {
+ "Config": {
+ "Description": "Config returns the image.Config for the specified path relative to the\nworking directory.",
+ "Args": [
+ "path"
+ ],
+ "Aliases": [
+ "imageConfig"
+ ],
+ "Examples": []
+ }
+ },
+ "inflect": {
+ "Humanize": {
+ "Description": "Humanize returns the humanized form of a single parameter.\n\nIf the parameter is either an integer or a string containing an integer\nvalue, the behavior is to add the appropriate ordinal.\n\n Example: \"my-first-post\" -\u003e \"My first post\"\n Example: \"103\" -\u003e \"103rd\"\n Example: 52 -\u003e \"52nd\"",
+ "Args": [
+ "in"
+ ],
+ "Aliases": [
+ "humanize"
+ ],
+ "Examples": [
+ [
+ "{{ humanize \"my-first-post\" }}",
+ "My first post"
+ ],
+ [
+ "{{ humanize \"myCamelPost\" }}",
+ "My camel post"
+ ],
+ [
+ "{{ humanize \"52\" }}",
+ "52nd"
+ ],
+ [
+ "{{ humanize 103 }}",
+ "103rd"
+ ]
+ ]
+ },
+ "Pluralize": {
+ "Description": "Pluralize returns the plural form of a single word.",
+ "Args": [
+ "in"
+ ],
+ "Aliases": [
+ "pluralize"
+ ],
+ "Examples": [
+ [
+ "{{ \"cat\" | pluralize }}",
+ "cats"
+ ]
+ ]
+ },
+ "Singularize": {
+ "Description": "Singularize returns the singular form of a single word.",
+ "Args": [
+ "in"
+ ],
+ "Aliases": [
+ "singularize"
+ ],
+ "Examples": [
+ [
+ "{{ \"cats\" | singularize }}",
+ "cat"
+ ]
+ ]
+ }
+ },
+ "lang": {
+ "Merge": {
+ "Description": "",
+ "Args": null,
+ "Aliases": null,
+ "Examples": null
+ },
+ "NumFmt": {
+ "Description": "NumFmt formats a number with the given precision using the\nnegative, decimal, and grouping options. The `options`\nparameter is a string consisting of `\u003cnegative\u003e \u003cdecimal\u003e \u003cgrouping\u003e`. The\ndefault `options` value is `- . ,`.\n\nNote that numbers are rounded up at 5 or greater.\nSo, with precision set to 0, 1.5 becomes `2`, and 1.4 becomes `1`.",
+ "Args": [
+ "precision",
+ "number",
+ "options"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{ lang.NumFmt 2 12345.6789 }}",
+ "12,345.68"
+ ],
+ [
+ "{{ lang.NumFmt 2 12345.6789 \"- , .\" }}",
+ "12.345,68"
+ ],
+ [
+ "{{ lang.NumFmt 6 -12345.6789 \"- .\" }}",
+ "-12345.678900"
+ ],
+ [
+ "{{ lang.NumFmt 0 -12345.6789 \"- . ,\" }}",
+ "-12,346"
+ ],
+ [
+ "{{ -98765.4321 | lang.NumFmt 2 }}",
+ "-98,765.43"
+ ]
+ ]
+ },
+ "Translate": {
+ "Description": "Translate ...",
+ "Args": [
+ "id",
+ "args"
+ ],
+ "Aliases": [
+ "i18n",
+ "T"
+ ],
+ "Examples": []
+ }
+ },
+ "math": {
+ "Add": {
+ "Description": "Add adds two numbers.",
+ "Args": [
+ "a",
+ "b"
+ ],
+ "Aliases": [
+ "add"
+ ],
+ "Examples": [
+ [
+ "{{add 1 2}}",
+ "3"
+ ]
+ ]
+ },
+ "Ceil": {
+ "Description": "Ceil returns the least integer value greater than or equal to x.",
+ "Args": [
+ "x"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{math.Ceil 2.1}}",
+ "3"
+ ]
+ ]
+ },
+ "Div": {
+ "Description": "Div divides two numbers.",
+ "Args": [
+ "a",
+ "b"
+ ],
+ "Aliases": [
+ "div"
+ ],
+ "Examples": [
+ [
+ "{{div 6 3}}",
+ "2"
+ ]
+ ]
+ },
+ "Floor": {
+ "Description": "Floor returns the greatest integer value less than or equal to x.",
+ "Args": [
+ "x"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{math.Floor 1.9}}",
+ "1"
+ ]
+ ]
+ },
+ "Log": {
+ "Description": "Log returns the natural logarithm of a number.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{math.Log 1}}",
+ "0"
+ ]
+ ]
+ },
+ "Mod": {
+ "Description": "Mod returns a % b.",
+ "Args": [
+ "a",
+ "b"
+ ],
+ "Aliases": [
+ "mod"
+ ],
+ "Examples": [
+ [
+ "{{mod 15 3}}",
+ "0"
+ ]
+ ]
+ },
+ "ModBool": {
+ "Description": "ModBool returns the boolean of a % b. If a % b == 0, return true.",
+ "Args": [
+ "a",
+ "b"
+ ],
+ "Aliases": [
+ "modBool"
+ ],
+ "Examples": [
+ [
+ "{{modBool 15 3}}",
+ "true"
+ ]
+ ]
+ },
+ "Mul": {
+ "Description": "Mul multiplies two numbers.",
+ "Args": [
+ "a",
+ "b"
+ ],
+ "Aliases": [
+ "mul"
+ ],
+ "Examples": [
+ [
+ "{{mul 2 3}}",
+ "6"
+ ]
+ ]
+ },
+ "Round": {
+ "Description": "Round returns the nearest integer, rounding half away from zero.",
+ "Args": [
+ "x"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{math.Round 1.5}}",
+ "2"
+ ]
+ ]
+ },
+ "Sub": {
+ "Description": "Sub subtracts two numbers.",
+ "Args": [
+ "a",
+ "b"
+ ],
+ "Aliases": [
+ "sub"
+ ],
+ "Examples": [
+ [
+ "{{sub 3 2}}",
+ "1"
+ ]
+ ]
+ }
+ },
+ "os": {
++ "Stat": {
++ "Description": "Stat returns a file infomation under the given path.",
++ "Args": [
++ "i"
++ ],
++ "Aliases": null,
++ "Examples": [
++ [
++ "{{ (os.Stat \"foo.txt\").Name }}",
++ "foo.txt"
++ ]
++ ]
++ },
+ "FileExists": {
+ "Description": "FileExists checks whether a file exists under the given path.",
+ "Args": [
+ "i"
+ ],
+ "Aliases": [
+ "fileExists"
+ ],
+ "Examples": [
+ [
+ "{{ fileExists \"foo.txt\" }}",
+ "false"
+ ]
+ ]
+ },
+ "Getenv": {
+ "Description": "Getenv retrieves the value of the environment variable named by the key.\nIt returns the value, which will be empty if the variable is not present.",
+ "Args": [
+ "key"
+ ],
+ "Aliases": [
+ "getenv"
+ ],
+ "Examples": []
+ },
+ "ReadDir": {
+ "Description": "ReadDir lists the directory contents relative to the configured WorkingDir.",
+ "Args": [
+ "i"
+ ],
+ "Aliases": [
+ "readDir"
+ ],
+ "Examples": [
+ [
+ "{{ range (readDir \".\") }}{{ .Name }}{{ end }}",
+ "README.txt"
+ ]
+ ]
+ },
+ "ReadFile": {
+ "Description": "ReadFile reads the file named by filename relative to the configured WorkingDir.\nIt returns the contents as a string.\nThere is an upper size limit set at 1 megabytes.",
+ "Args": [
+ "i"
+ ],
+ "Aliases": [
+ "readFile"
+ ],
+ "Examples": [
+ [
+ "{{ readFile \"README.txt\" }}",
+ "Hugo Rocks!"
+ ]
+ ]
+ }
+ },
+ "partials": {
+ "Include": {
+ "Description": "Include executes the named partial and returns either a string,\nwhen the partial is a text/template, or template.HTML when html/template.",
+ "Args": [
+ "name",
+ "contextList"
+ ],
+ "Aliases": [
+ "partial"
+ ],
+ "Examples": [
+ [
+ "{{ partial \"header.html\" . }}",
+ "\u003ctitle\u003eHugo Rocks!\u003c/title\u003e"
+ ]
+ ]
+ },
+ "IncludeCached": {
+ "Description": "IncludeCached executes and caches partial templates. An optional variant\nstring parameter (a string slice actually, but be only use a variadic\nargument to make it optional) can be passed so that a given partial can have\nmultiple uses. The cache is created with name+variant as the key.",
+ "Args": [
+ "name",
+ "context",
+ "variant"
+ ],
+ "Aliases": [
+ "partialCached"
+ ],
+ "Examples": []
+ }
+ },
+ "path": {
+ "Base": {
+ "Description": "",
+ "Args": null,
+ "Aliases": null,
+ "Examples": null
+ },
+ "Dir": {
+ "Description": "",
+ "Args": null,
+ "Aliases": null,
+ "Examples": null
+ },
+ "Ext": {
+ "Description": "",
+ "Args": null,
+ "Aliases": null,
+ "Examples": null
+ },
+ "Join": {
+ "Description": "Join joins any number of path elements into a single path, adding a\nseparating slash if necessary. All the input\npath elements are passed into filepath.ToSlash converting any Windows slashes\nto forward slashes.\nThe result is Cleaned; in particular,\nall empty strings are ignored.",
+ "Args": [
+ "elements"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{ slice \"my/path\" \"filename.txt\" | path.Join }}",
+ "my/path/filename.txt"
+ ],
+ [
+ "{{ path.Join \"my\" \"path\" \"filename.txt\" }}",
+ "my/path/filename.txt"
+ ],
+ [
+ "{{ \"my/path/filename.txt\" | path.Ext }}",
+ ".txt"
+ ],
+ [
+ "{{ \"my/path/filename.txt\" | path.Base }}",
+ "filename.txt"
+ ],
+ [
+ "{{ \"my/path/filename.txt\" | path.Dir }}",
+ "my/path"
+ ]
+ ]
+ },
+ "Split": {
+ "Description": "Split splits path immediately following the final slash,\nseparating it into a directory and file name component.\nIf there is no slash in path, Split returns an empty dir and\nfile set to path.\nThe input path is passed into filepath.ToSlash converting any Windows slashes\nto forward slashes.\nThe returned values have the property that path = dir+file.",
+ "Args": [
+ "path"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{ \"/my/path/filename.txt\" | path.Split }}",
+ "/my/path/|filename.txt"
+ ],
+ [
+ "{{ \"/my/path/filename.txt\" | path.Split }}",
+ "/my/path/|filename.txt"
+ ]
+ ]
+ }
+ },
+ "safe": {
+ "CSS": {
+ "Description": "CSS returns a given string as html/template CSS content.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "safeCSS"
+ ],
+ "Examples": [
+ [
+ "{{ \"Bat\u0026Man\" | safeCSS | safeCSS }}",
+ "Bat\u0026amp;Man"
+ ]
+ ]
+ },
+ "HTML": {
+ "Description": "HTML returns a given string as html/template HTML content.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "safeHTML"
+ ],
+ "Examples": [
+ [
+ "{{ \"Bat\u0026Man\" | safeHTML | safeHTML }}",
+ "Bat\u0026Man"
+ ],
+ [
+ "{{ \"Bat\u0026Man\" | safeHTML }}",
+ "Bat\u0026Man"
+ ]
+ ]
+ },
+ "HTMLAttr": {
+ "Description": "HTMLAttr returns a given string as html/template HTMLAttr content.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "safeHTMLAttr"
+ ],
+ "Examples": []
+ },
+ "JS": {
+ "Description": "JS returns the given string as a html/template JS content.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "safeJS"
+ ],
+ "Examples": [
+ [
+ "{{ \"(1*2)\" | safeJS | safeJS }}",
+ "(1*2)"
+ ]
+ ]
+ },
+ "JSStr": {
+ "Description": "JSStr returns the given string as a html/template JSStr content.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "safeJSStr"
+ ],
+ "Examples": []
+ },
+ "SanitizeURL": {
+ "Description": "SanitizeURL returns a given string as html/template URL content.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "sanitizeURL",
+ "sanitizeurl"
+ ],
+ "Examples": []
+ },
+ "URL": {
+ "Description": "URL returns a given string as html/template URL content.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "safeURL"
+ ],
+ "Examples": [
+ [
+ "{{ \"http://gohugo.io\" | safeURL | safeURL }}",
+ "http://gohugo.io"
+ ]
+ ]
+ }
+ },
+ "strings": {
+ "Chomp": {
+ "Description": "Chomp returns a copy of s with all trailing newline characters removed.",
+ "Args": [
+ "s"
+ ],
+ "Aliases": [
+ "chomp"
+ ],
+ "Examples": [
+ [
+ "{{chomp \"\u003cp\u003eBlockhead\u003c/p\u003e\\n\" | safeHTML }}",
+ "\u003cp\u003eBlockhead\u003c/p\u003e"
+ ]
+ ]
+ },
+ "Contains": {
+ "Description": "",
+ "Args": null,
+ "Aliases": null,
+ "Examples": null
+ },
+ "ContainsAny": {
+ "Description": "",
+ "Args": null,
+ "Aliases": null,
+ "Examples": null
+ },
+ "CountRunes": {
+ "Description": "CountRunes returns the number of runes in s, excluding whitepace.",
+ "Args": [
+ "s"
+ ],
+ "Aliases": [
+ "countrunes"
+ ],
+ "Examples": []
+ },
+ "CountWords": {
+ "Description": "CountWords returns the approximate word count in s.",
+ "Args": [
+ "s"
+ ],
+ "Aliases": [
+ "countwords"
+ ],
+ "Examples": []
+ },
+ "FindRE": {
+ "Description": "FindRE returns a list of strings that match the regular expression. By default all matches\nwill be included. The number of matches can be limited with an optional third parameter.",
+ "Args": [
+ "expr",
+ "content",
+ "limit"
+ ],
+ "Aliases": [
+ "findRE"
+ ],
+ "Examples": [
+ [
+ "{{ findRE \"[G|g]o\" \"Hugo is a static side generator written in Go.\" \"1\" }}",
+ "[go]"
+ ]
+ ]
+ },
+ "HasPrefix": {
+ "Description": "HasPrefix tests whether the input s begins with prefix.",
+ "Args": [
+ "s",
+ "prefix"
+ ],
+ "Aliases": [
+ "hasPrefix"
+ ],
+ "Examples": [
+ [
+ "{{ hasPrefix \"Hugo\" \"Hu\" }}",
+ "true"
+ ],
+ [
+ "{{ hasPrefix \"Hugo\" \"Fu\" }}",
+ "false"
+ ]
+ ]
+ },
+ "HasSuffix": {
+ "Description": "",
+ "Args": null,
+ "Aliases": null,
+ "Examples": null
+ },
+ "Repeat": {
+ "Description": "Repeat returns a new string consisting of count copies of the string s.",
+ "Args": [
+ "n",
+ "s"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{ \"yo\" | strings.Repeat 4 }}",
+ "yoyoyoyo"
+ ]
+ ]
+ },
+ "Replace": {
+ "Description": "Replace returns a copy of the string s with all occurrences of old replaced\nwith new.",
+ "Args": [
+ "s",
+ "old",
+ "new"
+ ],
+ "Aliases": [
+ "replace"
+ ],
+ "Examples": [
+ [
+ "{{ replace \"Batman and Robin\" \"Robin\" \"Catwoman\" }}",
+ "Batman and Catwoman"
+ ]
+ ]
+ },
+ "ReplaceRE": {
+ "Description": "ReplaceRE returns a copy of s, replacing all matches of the regular\nexpression pattern with the replacement text repl.",
+ "Args": [
+ "pattern",
+ "repl",
+ "s"
+ ],
+ "Aliases": [
+ "replaceRE"
+ ],
+ "Examples": []
+ },
+ "RuneCount": {
+ "Description": "RuneCount returns the number of runes in s.",
+ "Args": [
+ "s"
+ ],
+ "Aliases": null,
+ "Examples": []
+ },
+ "SliceString": {
+ "Description": "SliceString slices a string by specifying a half-open range with\ntwo indices, start and end. 1 and 4 creates a slice including elements 1 through 3.\nThe end index can be omitted, it defaults to the string's length.",
+ "Args": [
+ "a",
+ "startEnd"
+ ],
+ "Aliases": [
+ "slicestr"
+ ],
+ "Examples": [
+ [
+ "{{slicestr \"BatMan\" 0 3}}",
+ "Bat"
+ ],
+ [
+ "{{slicestr \"BatMan\" 3}}",
+ "Man"
+ ]
+ ]
+ },
+ "Split": {
+ "Description": "Split slices an input string into all substrings separated by delimiter.",
+ "Args": [
+ "a",
+ "delimiter"
+ ],
+ "Aliases": [
+ "split"
+ ],
+ "Examples": []
+ },
+ "Substr": {
+ "Description": "Substr extracts parts of a string, beginning at the character at the specified\nposition, and returns the specified number of characters.\n\nIt normally takes two parameters: start and length.\nIt can also take one parameter: start, i.e. length is omitted, in which case\nthe substring starting from start until the end of the string will be returned.\n\nTo extract characters from the end of the string, use a negative start number.\n\nIn addition, borrowing from the extended behavior described at http://php.net/substr,\nif length is given and is negative, then that many characters will be omitted from\nthe end of string.",
+ "Args": [
+ "a",
+ "nums"
+ ],
+ "Aliases": [
+ "substr"
+ ],
+ "Examples": [
+ [
+ "{{substr \"BatMan\" 0 -3}}",
+ "Bat"
+ ],
+ [
+ "{{substr \"BatMan\" 3 3}}",
+ "Man"
+ ]
+ ]
+ },
+ "Title": {
+ "Description": "Title returns a copy of the input s with all Unicode letters that begin words\nmapped to their title case.",
+ "Args": [
+ "s"
+ ],
+ "Aliases": [
+ "title"
+ ],
+ "Examples": [
+ [
+ "{{title \"Bat man\"}}",
+ "Bat Man"
+ ],
+ [
+ "{{title \"somewhere over the rainbow\"}}",
+ "Somewhere Over the Rainbow"
+ ]
+ ]
+ },
+ "ToLower": {
+ "Description": "ToLower returns a copy of the input s with all Unicode letters mapped to their\nlower case.",
+ "Args": [
+ "s"
+ ],
+ "Aliases": [
+ "lower"
+ ],
+ "Examples": [
+ [
+ "{{lower \"BatMan\"}}",
+ "batman"
+ ]
+ ]
+ },
+ "ToUpper": {
+ "Description": "ToUpper returns a copy of the input s with all Unicode letters mapped to their\nupper case.",
+ "Args": [
+ "s"
+ ],
+ "Aliases": [
+ "upper"
+ ],
+ "Examples": [
+ [
+ "{{upper \"BatMan\"}}",
+ "BATMAN"
+ ]
+ ]
+ },
+ "Trim": {
+ "Description": "Trim returns a string with all leading and trailing characters defined\ncontained in cutset removed.",
+ "Args": [
+ "s",
+ "cutset"
+ ],
+ "Aliases": [
+ "trim"
+ ],
+ "Examples": [
+ [
+ "{{ trim \"++Batman--\" \"+-\" }}",
+ "Batman"
+ ]
+ ]
+ },
+ "TrimLeft": {
+ "Description": "TrimLeft returns a slice of the string s with all leading characters\ncontained in cutset removed.",
+ "Args": [
+ "cutset",
+ "s"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{ \"aabbaa\" | strings.TrimLeft \"a\" }}",
+ "bbaa"
+ ]
+ ]
+ },
+ "TrimPrefix": {
+ "Description": "TrimPrefix returns s without the provided leading prefix string. If s doesn't\nstart with prefix, s is returned unchanged.",
+ "Args": [
+ "prefix",
+ "s"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{ \"aabbaa\" | strings.TrimPrefix \"a\" }}",
+ "abbaa"
+ ],
+ [
+ "{{ \"aabbaa\" | strings.TrimPrefix \"aa\" }}",
+ "bbaa"
+ ]
+ ]
+ },
+ "TrimRight": {
+ "Description": "TrimRight returns a slice of the string s with all trailing characters\ncontained in cutset removed.",
+ "Args": [
+ "cutset",
+ "s"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{ \"aabbaa\" | strings.TrimRight \"a\" }}",
+ "aabb"
+ ]
+ ]
+ },
+ "TrimSuffix": {
+ "Description": "TrimSuffix returns s without the provided trailing suffix string. If s\ndoesn't end with suffix, s is returned unchanged.",
+ "Args": [
+ "suffix",
+ "s"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{ \"aabbaa\" | strings.TrimSuffix \"a\" }}",
+ "aabba"
+ ],
+ [
+ "{{ \"aabbaa\" | strings.TrimSuffix \"aa\" }}",
+ "aabb"
+ ]
+ ]
+ },
+ "Truncate": {
+ "Description": "Truncate truncates a given string to the specified length.",
+ "Args": [
+ "a",
+ "options"
+ ],
+ "Aliases": [
+ "truncate"
+ ],
+ "Examples": [
+ [
+ "{{ \"this is a very long text\" | truncate 10 \" ...\" }}",
+ "this is a ..."
+ ],
+ [
+ "{{ \"With [Markdown](/markdown) inside.\" | markdownify | truncate 14 }}",
+ "With \u003ca href=\"/markdown\"\u003eMarkdown …\u003c/a\u003e"
+ ]
+ ]
+ }
+ },
+ "time": {
+ "AsTime": {
+ "Description": "AsTime converts the textual representation of the datetime string into\na time.Time interface.",
+ "Args": [
+ "v"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{ (time \"2015-01-21\").Year }}",
+ "2015"
+ ]
+ ]
+ },
+ "Duration": {
+ "Description": "Duration converts the given number to a time.Duration.\nUnit is one of nanosecond/ns, microsecond/us/µs, millisecond/ms, second/s, minute/m or hour/h.",
+ "Args": [
+ "unit",
+ "number"
+ ],
+ "Aliases": [
+ "duration"
+ ],
+ "Examples": [
+ [
+ "{{ mul 60 60 | duration \"second\" }}",
+ "1h0m0s"
+ ]
+ ]
+ },
+ "Format": {
+ "Description": "Format converts the textual representation of the datetime string into\nthe other form or returns it of the time.Time value. These are formatted\nwith the layout string",
+ "Args": [
+ "layout",
+ "v"
+ ],
+ "Aliases": [
+ "dateFormat"
+ ],
+ "Examples": [
+ [
+ "dateFormat: {{ dateFormat \"Monday, Jan 2, 2006\" \"2015-01-21\" }}",
+ "dateFormat: Wednesday, Jan 21, 2015"
+ ]
+ ]
+ },
+ "Now": {
+ "Description": "Now returns the current local time.",
+ "Args": null,
+ "Aliases": [
+ "now"
+ ],
+ "Examples": []
+ },
+ "ParseDuration": {
+ "Description": "ParseDuration parses a duration string.\nA duration string is a possibly signed sequence of\ndecimal numbers, each with optional fraction and a unit suffix,\nsuch as \"300ms\", \"-1.5h\" or \"2h45m\".\nValid time units are \"ns\", \"us\" (or \"µs\"), \"ms\", \"s\", \"m\", \"h\".\nSee https://golang.org/pkg/time/#ParseDuration",
+ "Args": [
+ "in"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{ \"1h12m10s\" | time.ParseDuration }}",
+ "1h12m10s"
+ ]
+ ]
+ }
+ },
+ "transform": {
+ "Emojify": {
+ "Description": "Emojify returns a copy of s with all emoji codes replaced with actual emojis.\n\nSee http://www.emoji-cheat-sheet.com/",
+ "Args": [
+ "s"
+ ],
+ "Aliases": [
+ "emojify"
+ ],
+ "Examples": [
+ [
+ "{{ \"I :heart: Hugo\" | emojify }}",
+ "I ❤️ Hugo"
+ ]
+ ]
+ },
+ "HTMLEscape": {
+ "Description": "HTMLEscape returns a copy of s with reserved HTML characters escaped.",
+ "Args": [
+ "s"
+ ],
+ "Aliases": [
+ "htmlEscape"
+ ],
+ "Examples": [
+ [
+ "{{ htmlEscape \"Cathal Garvey \u0026 The Sunshine Band \u003ccathal@foo.bar\u003e\" | safeHTML}}",
+ "Cathal Garvey \u0026amp; The Sunshine Band \u0026lt;cathal@foo.bar\u0026gt;"
+ ],
+ [
+ "{{ htmlEscape \"Cathal Garvey \u0026 The Sunshine Band \u003ccathal@foo.bar\u003e\"}}",
+ "Cathal Garvey \u0026amp;amp; The Sunshine Band \u0026amp;lt;cathal@foo.bar\u0026amp;gt;"
+ ],
+ [
+ "{{ htmlEscape \"Cathal Garvey \u0026 The Sunshine Band \u003ccathal@foo.bar\u003e\" | htmlUnescape | safeHTML }}",
+ "Cathal Garvey \u0026 The Sunshine Band \u003ccathal@foo.bar\u003e"
+ ]
+ ]
+ },
+ "HTMLUnescape": {
+ "Description": "HTMLUnescape returns a copy of with HTML escape requences converted to plain\ntext.",
+ "Args": [
+ "s"
+ ],
+ "Aliases": [
+ "htmlUnescape"
+ ],
+ "Examples": [
+ [
+ "{{ htmlUnescape \"Cathal Garvey \u0026amp; The Sunshine Band \u0026lt;cathal@foo.bar\u0026gt;\" | safeHTML}}",
+ "Cathal Garvey \u0026 The Sunshine Band \u003ccathal@foo.bar\u003e"
+ ],
+ [
+ "{{\"Cathal Garvey \u0026amp;amp; The Sunshine Band \u0026amp;lt;cathal@foo.bar\u0026amp;gt;\" | htmlUnescape | htmlUnescape | safeHTML}}",
+ "Cathal Garvey \u0026 The Sunshine Band \u003ccathal@foo.bar\u003e"
+ ],
+ [
+ "{{\"Cathal Garvey \u0026amp;amp; The Sunshine Band \u0026amp;lt;cathal@foo.bar\u0026amp;gt;\" | htmlUnescape | htmlUnescape }}",
+ "Cathal Garvey \u0026amp; The Sunshine Band \u0026lt;cathal@foo.bar\u0026gt;"
+ ],
+ [
+ "{{ htmlUnescape \"Cathal Garvey \u0026amp; The Sunshine Band \u0026lt;cathal@foo.bar\u0026gt;\" | htmlEscape | safeHTML }}",
+ "Cathal Garvey \u0026amp; The Sunshine Band \u0026lt;cathal@foo.bar\u0026gt;"
+ ]
+ ]
+ },
+ "Highlight": {
+ "Description": "Highlight returns a copy of s as an HTML string with syntax\nhighlighting applied.",
+ "Args": [
+ "s",
+ "lang",
+ "opts"
+ ],
+ "Aliases": [
+ "highlight"
+ ],
+ "Examples": []
+ },
+ "Markdownify": {
+ "Description": "Markdownify renders a given input from Markdown to HTML.",
+ "Args": [
+ "s"
+ ],
+ "Aliases": [
+ "markdownify"
+ ],
+ "Examples": [
+ [
+ "{{ .Title | markdownify}}",
+ "\u003cstrong\u003eBatMan\u003c/strong\u003e"
+ ]
+ ]
+ },
+ "Plainify": {
+ "Description": "Plainify returns a copy of s with all HTML tags removed.",
+ "Args": [
+ "s"
+ ],
+ "Aliases": [
+ "plainify"
+ ],
+ "Examples": [
+ [
+ "{{ plainify \"Hello \u003cstrong\u003eworld\u003c/strong\u003e, gophers!\" }}",
+ "Hello world, gophers!"
+ ]
+ ]
+ },
+ "Remarshal": {
+ "Description": "Remarshal is used in the Hugo documentation to convert configuration\nexamples from YAML to JSON, TOML (and possibly the other way around).\nThe is primarily a helper for the Hugo docs site.\nIt is not a general purpose YAML to TOML converter etc., and may\nchange without notice if it serves a purpose in the docs.\nFormat is one of json, yaml or toml.",
+ "Args": [
+ "format",
+ "data"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{ \"title = \\\"Hello World\\\"\" | transform.Remarshal \"json\" | safeHTML }}",
+ "{\n \"title\": \"Hello World\"\n}\n"
+ ]
+ ]
+ }
+ },
+ "urls": {
+ "AbsLangURL": {
+ "Description": "AbsLangURL takes a given string and converts it to an absolute URL according\nto a page's position in the project directory structure and the current\nlanguage.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "absLangURL"
+ ],
+ "Examples": []
+ },
+ "AbsURL": {
+ "Description": "AbsURL takes a given string and converts it to an absolute URL.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "absURL"
+ ],
+ "Examples": []
+ },
+ "Anchorize": {
+ "Description": "Anchorize creates sanitized anchor names that are compatible with Blackfriday.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "anchorize"
+ ],
+ "Examples": [
+ [
+ "{{ \"This is a title\" | anchorize }}",
+ "this-is-a-title"
+ ]
+ ]
+ },
+ "Parse": {
+ "Description": "",
+ "Args": null,
+ "Aliases": null,
+ "Examples": null
+ },
+ "Ref": {
+ "Description": "Ref returns the absolute URL path to a given content item.",
+ "Args": [
+ "in",
+ "refs"
+ ],
+ "Aliases": [
+ "ref"
+ ],
+ "Examples": []
+ },
+ "RelLangURL": {
+ "Description": "RelLangURL takes a given string and prepends the relative path according to a\npage's position in the project directory structure and the current language.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "relLangURL"
+ ],
+ "Examples": []
+ },
+ "RelRef": {
+ "Description": "RelRef returns the relative URL path to a given content item.",
+ "Args": [
+ "in",
+ "refs"
+ ],
+ "Aliases": [
+ "relref"
+ ],
+ "Examples": []
+ },
+ "RelURL": {
+ "Description": "RelURL takes a given string and prepends the relative path according to a\npage's position in the project directory structure.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "relURL"
+ ],
+ "Examples": []
+ },
+ "URLize": {
+ "Description": "URLize returns the given argument formatted as URL.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "urlize"
+ ],
+ "Examples": []
+ }
+ }
+ }
+ }
+}
--- /dev/null
++[[quotes]]
++name = "Joshua Steven"
++twitter_handle = "@jscarto"
++quote = "Can't overstate how much I enjoy @GoHugoIO. My site is relatively small, but *18 ms* to build the whole thing made template development and proofing a breeze."
++link = "https://twitter.com/jscarto/status/1039648827815485440"
++date = 2018-09-12T00:00:00Z
+
+[[quotes]]
+name = "Execute"
+twitter_handle = "@executerun"
+quote = "Hah, #gohugo. I was working with #gohugo on #linux but now I realised how easy is to set-up it on #windows. Just need to add binary to #path!"
+link = "https://twitter.com/executerun/status/809753145270272005"
+date = 2016-12-16T00:00:00Z
+
+
+[[quotes]]
+name = "Janez Čadež"
+twitter_handle = "@jamziSLO"
+quote = "Building @garazaFRI website in #hugo. This static site generator is soooo damn fast!"
+link = "https://twitter.com/jamziSLO/status/817720283977183234"
+date = 2017-01-07T00:00:00Z
+
+[[quotes]]
+name = "Hans Beck"
+twitter_handle = "@EnrichedGamesHB"
+quote = "Diving deeper into @GoHugoIO . A lot of docs there, top work! But I've the impressed that #gohugo is far easier than its feels from the docs!"
+link = "https://twitter.com/EnrichedGamesHB/status/836854762440130560"
+date = 2017-03-01T00:00:00Z
+
+[[quotes]]
+name = "Alan Richardson"
+twitter_handle = "@eviltester"
+quote = "I migrated the <a href='https://twitter.com/BlackOpsTesting'> @BlackOpsTesting </a> .com website from docpad to Hugo last weekend. http://gohugo.io/ Super Fast HTML Generation <a href='https://twitter.com/spf13'> @spf13 </a>"
+link = "https://twitter.com/eviltester/status/553520335115808768"
+date = 2015-01-09T00:00:00Z
+
+[[quotes]]
+name = "Baron Schwartz"
+twitter_handle = "@xaprb"
+quote = "Hugo is impressively capable. It's a static site generator by <a href='https://twitter.com/spf13'> @spf13 </a> written in <a href='https://twitter.com/hashtag/golang?src=hash'> #golang </a> . Just upgraded to latest release; very powerful. "
+link = "https://twitter.com/xaprb/status/556894866488455169"
+date = 2015-01-18T00:00:00Z
+
+[[quotes]]
+name = "Dave Cottlehuber"
+twitter_handle = "@dch__"
+quote = "I just fell in love with #hugo, a static site/blog engine written by @spf13 in #golang + stellar docs"
+link = "https://twitter.com/dch__/status/460158115498176512"
+date = 2014-04-26T00:00:00Z
+
+[[quotes]]
+name = "David Caunt"
+twitter_handle = "@dcaunt"
+quote = "I had a play with Hugo and it was good, uses Markdown files for content"
+link = "https://twitter.com/dcaunt/statuses/406466996277374976"
+date = 2013-11-29T00:00:00Z
+
+[[quotes]]
+name = "David Gay"
+twitter_handle = "@oddshocks"
+quote = "Hugo is super-rad."
+link = "https://twitter.com/oddshocks/statuses/405083217893421056"
+date = 2013-11-25T00:00:00Z
+
+[[quotes]]
+name = "Diti"
+twitter_handle = "@DitiPengi"
+quote = "The dev version of Hugo is AWESOME! <3 I promise, I will try to learn go ASAP and help contribute to the project! Just too great!"
+link = "https://twitter.com/DitiPengi/status/472470974051676160"
+date = 2014-05-30T00:00:00Z
+
+[[quotes]]
+name = "Douglas Stephen "
+twitter_handle = "@DougStephenJr"
+quote = "Even as a long-time Octopress fan, I’ve gotta admit that this project Hugo looks very very cool"
+link = "https://twitter.com/DougStephenJr/statuses/364512471660249088"
+date = 2013-08-05T00:00:00Z
+
+[[quotes]]
+name = "Hugo Rodger-Brown"
+twitter_handle = "@hugorodgerbrown"
+quote = "Finally someone builds me my own static site generator"
+link = "https://twitter.com/hugorodgerbrown/statuses/364417910153818112"
+date = 2013-05-08T00:00:00Z
+
+[[quotes]]
+name = "Hugo Roy"
+twitter_handle = "@hugoroyd"
+quote = "Finally the answer to the question my parents have been asking: What does Hugo do?"
+link = "https://twitter.com/hugoroyd/status/501704796727173120"
+date = 2014-08-19T00:00:00Z
+
+[[quotes]]
+name = "Daniel Miessler"
+twitter_handle = "@DanielMiessler"
+quote = "Websites for named vulnerabilities should run on static site generator platforms like Hugo. Read-only + burst traffic = static."
+link = "https://twitter.com/DanielMiessler/status/704703841673957376"
+date = 2016-03-01T00:00:00Z
+
+[[quotes]]
+name = "Javier Segura"
+twitter_handle = "@jsegura"
+quote = "Another site generated with Hugo here! I'm getting in love with it."
+link = "https://twitter.com/jsegura/status/465978434154659841"
+date = 2014-05-12T00:00:00Z
+
+[[quotes]]
+name = "Jim Biancolo"
+twitter_handle = "@jimbiancolo"
+quote = "I’m loving the static site generator renaissance we are currently enjoying. Hugo is new, looks great, written in Go"
+link = "https://twitter.com/jimbiancolo/statuses/408678420348813314"
+date = 2013-05-12T00:00:00Z
+
+[[quotes]]
+name = "Jip J. Dekker"
+twitter_handle = "@jipjdekker"
+quote = "Building a personal website in Hugo. Works like a charm. And written in @golang!"
+link = "https://twitter.com/jipjdekker/status/413783548735152131"
+date = 2013-12-19T00:00:00Z
+
+[[quotes]]
+name = "Jose Gonzalvo"
+twitter_handle = "@jgonzalvo"
+quote = "Checking out Hugo; Loving it so far. Like Jekyll but not so blog-oriented and written in go"
+link = "https://twitter.com/jgonzalvo/statuses/408177855819173888"
+date = 2013-12-04T00:00:00Z
+
+[[quotes]]
+name = "Josh Matz"
+twitter_handle = "@joshmatz"
+quote = "A static site generator without the long build times? Yes, please!"
+link = "https://twitter.com/joshmatz/statuses/364437436870696960"
+date = 2013-08-05T00:00:00Z
+
+[[quotes]]
+name = "Kieran Healy"
+twitter_handle = "@kjhealy"
+quote = "OK, so in today's speed battle of static site generators, @spf13's hugo is kicking everyone's ass, by miles."
+link = "https://twitter.com/kjhealy/status/437349384809115648"
+date = 2014-02-22T00:00:00Z
+
+[[quotes]]
+name = "Ludovic Chabant"
+twitter_handle = "@ludovicchabant"
+quote = "Good work on Hugo, I’m impressed with the speed!"
+link = "https://twitter.com/ludovicchabant/statuses/408806199602053120"
+date = 2013-12-06T00:00:00Z
+
+[[quotes]]
+name = "Luke Holder"
+twitter_handle = "@lukeholder"
+quote = "this is AWESOME. a single little executable and so fast."
+link = "https://twitter.com/lukeholder/status/430352287936946176"
+date = 2014-02-03T00:00:00Z
+
+[[quotes]]
+name = "Markus Eliasson"
+twitter_handle = "@markuseliasson"
+quote = "Hugo is fast, dead simple to setup and well documented"
+link = "https://twitter.com/markuseliasson/status/501594865877008384"
+date = 2014-08-19T00:00:00Z
+
+[[quotes]]
+name = "mercime"
+twitter_handle = "@mercime_one"
+quote = "Hugo: Makes the Web Fun Again"
+link = "https://twitter.com/mercime_one/status/500547145087205377"
+date = 2014-08-16T00:00:00Z
+
+[[quotes]]
+name = "Michael Whatcott"
+twitter_handle = "@mdwhatcott"
+quote = "One more satisfied #Hugo blogger. Thanks @spf13 and friends!"
+link = "https://twitter.com/mdwhatcott/status/469980686531571712"
+date = 2014-05-23T00:00:00Z
+
+[[quotes]]
+name = "Nathan Toups"
+twitter_handle = "@rojoroboto"
+quote = "I love Hugo! My site is generated with it now http://rjrbt.io"
+link = "https://twitter.com/rojoroboto/status/423439915620106242"
+date = 2014-01-15T00:00:00Z
+
+[[quotes]]
+name = "Ruben Solvang"
+twitter_handle = "@messo85"
+quote = "#Hugo is the new @jekyllrb / @middlemanapp! Faster, easier and runs everywhere."
+link = "https://twitter.com/messo85/status/472825062027182081"
+date = 2014-05-31T00:00:00Z
+
+[[quotes]]
+name = "Ryan Martinsen"
+twitter_handle = "@popthestack"
+quote = "Also, I re-launched my blog (it looks the same as before) using Hugo, a *fast* static engine. Very happy with it. <a href='http://gohugo.io/'>gohugo.io</a>"
+link = "https://twitter.com/popthestack/status/549972754125307904"
+date = 2014-12-30T00:00:00Z
+
+[[quotes]]
+name = "The Lone Cuber"
+twitter_handle = "@TheLoneCuber"
+quote = "Jekyll is dead to me these days though... long live Hugo! Hugo is *by far* the best in its field. Thanks for making it happen."
+link = "https://twitter.com/TheLoneCuber/status/495716684456398848"
+date = 2014-08-02T00:00:00Z
+
+[[quotes]]
+name = "The Lone Cuber"
+twitter_handle = "@TheLoneCuber"
+quote = "Finally, a publishing platform that's a joy to use. #NoMoreBarriers"
+link = "https://twitter.com/TheLoneCuber/status/495731334711488512"
+date = 2014-08-02T00:00:00Z
+
+[[quotes]]
+name = "WorkHTML"
+twitter_handle = "@workhtml"
+quote = "<a href='https://twitter.com/hashtag/Hugo?src=hash'> #Hugo </a> A very good alternative for <a href='https://twitter.com/hashtag/wordpress?src=hash'> #wordpress </a> !!! A fast and modern static website engine <a href='http://gohugo.io/'> gohugo.io </a>"
+link = "https://twitter.com/workhtml/status/563064361301053440"
+date = 2015-02-04T00:00:00Z
--- /dev/null
- {{ $.Scratch.Set "codeLang" "" }}
+{{ $file := .Get "file" }}
- {{ $.Scratch.Set "codeLang" (index . 0 | strings.TrimPrefix ".") }}
++{{ $codeLang := "" }}
+{{ $suffix := findRE "(\\.[^.]+)$" $file 1 }}
+{{ with $suffix }}
- {{ with .Get "codeLang" }}{{ $.Scratch.Set "codeLang" . }}{{ end }}
- {{ if eq (.Scratch.Get "codeLang") "html"}}
- {{ $.Scratch.Set "codeLang" "go-html-template" }}
++{{ $codeLang = (index . 0 | strings.TrimPrefix ".") }}
+{{ end }}
- {{ if .Get "nocode" }}{{ $.Inner }}{{ else }}{{ with $.Scratch.Get "codeLang" }}{{- highlight $.Inner . "" | -}}{{ else }}<pre><code>{{- .Inner | string -}}</code></pre>{{ end }}{{ end }}
++{{ with .Get "codeLang" }}{{ $codeLang = . }}{{ end }}
++{{ if eq $codeLang "html"}}
++{{ $codeLang = "go-html-template" }}
+{{ end }}
+<div class="code relative" id="{{ $file | urlize}}">
+ {{- with $file -}}
+ <div class="filename san-serif f6 dib lh-solid pl2 pv2">{{.}}</div>
+ {{- end -}}
+
+ {{ if ne (.Get "copy") "false" }}
+ <button class="needs-js copy bg-accent-color-dark f6 absolute top-0 right-0 lh-solid hover-bg-primary-color-dark bn white ph3 pv2" title="Copy this code to your clipboard." data-clipboard-action="copy" aria-label="copy button">
+ </button>
+ {{/* Functionality located within filesaver.js The copy here is located in the css with .copy class so it can be replaced with JS on success */}}
+ {{end}}
+ <div class="code-copy-content nt3" {{with .Get "download"}}id="{{.}}"{{end}}>
++ {{ if .Get "nocode" }}{{ $.Inner }}{{ else }}{{ with $codeLang }}{{- highlight $.Inner . "" | -}}{{ else }}<pre><code>{{- .Inner | string -}}</code></pre>{{ end }}{{ end }}
+ </div>
+
+</div>
--- /dev/null
- command = "hugo"
+[build]
+publish = "public"
- HUGO_VERSION = "0.46"
++command = "hugo --minify"
+
+[context.production.environment]
- HUGO_VERSION = "0.46"
++HUGO_VERSION = "0.48"
+HUGO_ENV = "production"
+HUGO_ENABLEGITINFO = "true"
+
+[context.split1]
+command = "hugo --enableGitInfo"
+
+[context.split1.environment]
- HUGO_VERSION = "0.46"
++HUGO_VERSION = "0.48"
+HUGO_ENV = "production"
+
+[context.deploy-preview]
+command = "hugo --buildFuture -b $DEPLOY_PRIME_URL"
+
+[context.deploy-preview.environment]
- HUGO_VERSION = "0.46"
++HUGO_VERSION = "0.48"
+
+[context.branch-deploy]
+command = "hugo -b $DEPLOY_PRIME_URL"
+
+[context.branch-deploy.environment]
++HUGO_VERSION = "0.48"
+
+[context.next.environment]
+HUGO_ENABLEGITINFO = "true"
+
--- /dev/null
--- /dev/null
++*.* linguist-generated=true
++*.* -diff -merge
--- /dev/null
- </a> was last updated: {{ .Lastmod.Format "January 2, 2006" }}{{ with .GitInfo }}: <a class="hide-child link primary-color" href="{{$.Site.Params.ghrepo}}/commit/{{ .Hash }}">{{ .Subject }} ({{ .AbbreviatedHash }})</a>{{end }}
+<h6 class="f4 dark-gray mb2">
+ <a href="{{ .Permalink }}" class="hide-child link primary-color">
+ <span class="nl3 child">{{ partial "svg/link-permalink.svg" (dict "size" "14px") }}</span>
+ “{{ .Title }}”
++ </a> was last updated: {{ .Lastmod.Format "January 2, 2006" }}{{ with .GitInfo }}: <a class="hide-child link primary-color" href="{{$.Site.Params.ghrepo}}commit/{{ .Hash }}">{{ .Subject }} ({{ .AbbreviatedHash }})</a>{{end }}
+</h6>
--- /dev/null
- <a href="{{ .Prev.Permalink }}" class="db-l f4 f3-ns link primary-color hover-black fw8">
+{{if .Prev }}
-
- {{ if .Prev }}
++ <a href="{{ .Prev.Permalink }}" class="db-l f4 f3-ns link primary-color hover-black fw8 mr4">
+ <span class="v-mid dib">{{ partial "svg/ic_chevron_left_black_24px.svg" (dict "size" "30px") }}</span> {{ .Prev.Title }}
+ </a>
+{{end}}
+
+{{if .Next }}
+ <a href="{{.Next.Permalink }}" class="db-l f4 f3-ns link primary-color hover-black fw8">
+ {{ .Next.Title }} <span class="v-mid dib">{{ partial "svg/ic_chevron_right_black_24px.svg" (dict "size" "30px") }}</span>
+ </a>
+{{end}}
+
+
+<script>
+ document.body.onkeyup = function(e){
- {{ end }}
- {{ if .Next }}
- if (e.keyCode == '39') { window.location = '{{.Next.Permalink }}'; }
- {{ end }}
++ if (!(e.ctrlKey || e.shiftKey || e.altKey || e.metaKey)) {
++ {{- if .Prev }}
+ if (e.keyCode == '37') { window.location = '{{ .Prev.Permalink }}'; }
-
++ {{- end }}
++ {{- if .Next }}
++ if (e.keyCode == '39') { window.location = '{{ .Next.Permalink }}'; }
++ {{- end }}
++ }
+ };
+</script>
--- /dev/null
- By the <a href="https://github.com/gohugoio/hugo/contributors" class="link">Hugo Authors</a><br />
+<footer class="bg-primary-color-dark ph4-ns pt4 relative w-100" role="contentinfo">
+ <div class="center flex-ns flex-wrap justify-between mw9 w-90">
+ <div class="pb3 pt4 w-100 w-50-ns">
+
+ <div class="b f3 light-gray mb3 nested-links tc">
++ By the <a href="https://github.com/gohugoio/hugo/graphs/contributors" class="link">Hugo Authors</a><br />
+ </div>
+
+ <div class="center w4">
+ {{ partialCached "svg/hugo-logo-wide.svg" . }}
+ </div>
+
+ <ul class="center f6 list ma0 mv3 pa0 tc">
+ {{- with .Site.Params.github_repo -}}<li class="dib mr3"><a href="{{ . }}" class="dim link light-gray pv2">File an Issue</a></li>{{- end -}}
+ {{- with .Site.Params.forum -}}<li class="dib mr3"><a href="{{ . }}" class="dim link light-gray pv2">Get Help</a></li>{{- end -}}
+ {{- with .Site.Params.gitter -}}<li class="dib"><a href="{{ . }}" class="dim link light-gray pv2">Discuss Source Code</a></li>{{- end -}}
+ </ul>
+
+ <ul class="center f6 list ma0 mv4 pa0 tc">
+ <li class="dib mr3"><a href="https://twitter.com/gohugoio" class="dim link light-gray pv2">@GoHugoIO</a></li>
+ <li class="dib mr3"><a href="https://twitter.com/spf13" class="dim link light-gray pv2">@spf13</a></li>
+ <li class="dib"><a href="https://twitter.com/bepsays" class="dim link light-gray pv2">@bepsays</a></li>
+ </ul>
+
+ {{ with getenv "REPOSITORY_URL" -}}
+ <p class="center f6 tc w-70"><a href="https://www.netlify.com"><img src="https://www.netlify.com/img/global/badges/netlify-dark.svg"/></a></p>
+ {{- end }}
+
+ </div>
+
+ <div class="w-100 w-50-l">
+ {{ partial "home-page-sections/sponsors.html" (dict "cx" . "gtag" "footer" "classes_section" "pb3 w-100" "classes_copy" "f7 w-90-ns") }}
+ </div>
+
+ </div>
+
+ <div class="f7 gray mb5 mb0-ns ph3 w-100">
+ <p class="dib mr4">The Hugo logos are copyright © Steve Francia 2013–{{ now.Year }}.</p>
+ <p class="dib">The Hugo Gopher is based on an original work by Renée French.</p>
+ </div>
+
+ <img src="/images/gopher-side_color.svg" class="absolute-l bottom-0 dn db-l h4 right-0 z-999"/>
+
+ <div class="bg-primary-color-dark bottom-0 left-0 right-0 dn-l fixed pb3 ph3 w-100">
+ {{- partial "nav-mobile.html" . -}}
+ </div>
+
+</footer>
projects / brevno-suite / hugo / commitdiff
