releaser: Update /docs to 0.24 [ci skip]

[ci skip]

.gitignore

@@ -1,5 +1,18 @@
-hugo
-docs/public*
-hugo.exe
-*.swp
-.DS_Store
+hugo
+docs/public*
+/.idea
+hugo.exe
+*.test
+*.prof
+nohup.out
+cover.out
+*.swp
+*.swo
+.DS_Store
+*~
+vendor/*/
+*.bench
+coverage*.out
+
+GoBuilds
+dist

.gitmodules

@@ -0,0 +1,4 @@
+[submodule "docs"]
+	path = docs
+	url = https://github.com/gohugoio/hugoDocs.git
+	ignore = dirty

.goxc.json

@@ -0,0 +1,6 @@
+{
+	"ArtifactsDest": "GoBuilds/",
+	"OutPath": "{{.Dest}}{{.PS}}{{.AppName}}{{.PS}}{{.Version}}{{.PS}}{{.AppName}}_{{.Version}}_{{.Os}}_{{.Arch}}{{.Ext}}",
+	"BuildConstraints": "linux windows darwin freebsd netbsd openbsd dragonfly",
+	"ConfigVersion": "0.9"
+}

.mailmap

@@ -0,0 +1,3 @@
+spf13 <steve.francia@gmail.com> Steve Francia <steve.francia@gmail.com>
+bep <bjorn.erik.pedersen@gmail.com> Bjørn Erik Pedersen <bjorn.erik.pedersen@gmail.com>
+

.travis.yml

@@ -0,0 +1,21 @@
+language: go
+sudo: required
+go:
+  - 1.7.6
+  - 1.8.3
+  - tip
+os:
+  - linux
+  - osx
+matrix:
+  allow_failures:
+    - go: tip
+  fast_finish: true
+install:
+  - make vendor
+script:
+  - make hugo-race check
+before_install:
+  # gem install must be run with sudo on OSX
+  - sudo gem install asciidoctor | gem install asciidoctor
+  - sudo pip install docutils

CONTRIBUTING.md

@@ -0,0 +1,161 @@
+# Contributing to Hugo
+
+We welcome contributions to Hugo of any kind including documentation, themes,
+organization, tutorials, blog posts, bug reports, issues, feature requests,
+feature implementations, pull requests, answering questions on the forum,
+helping to manage issues, etc.
+
+The Hugo community and maintainers are [very active](https://github.com/gohugoio/hugo/pulse/monthly) and helpful, and the project benefits greatly from this activity. We created a [step by step guide](https://gohugo.io/tutorials/how-to-contribute-to-hugo/) if you're unfamiliar with GitHub or contributing to open source projects in general.
+
+## Table of Contents
+
+* [Asking Support Questions](#asking-support-questions)
+* [Reporting Issues](#reporting-issues)
+* [Submitting Patches](#submitting-patches)
+  * [Code Contribution Guidelines](#code-contribution-guidelines)
+  * [Git Commit Message Guidelines](#git-commit-message-guidelines)
+  * [Vendored Dependencies](#vendored-dependencies)
+  * [Fetching the Sources From GitHub](#fetching-the-sources-from-github)
+  * [Using Git Remotes](#using-git-remotes)
+  * [Build Hugo with Your Changes](#build-hugo-with-your-changes)
+  * [Updating the Hugo Sources](#updating-the-hugo-sources)
+
+## Asking Support Questions
+
+We have an active [discussion forum](https://discourse.gohugo.io) where users and developers can ask questions.
+Please don't use the GitHub issue tracker to ask questions.
+
+## Reporting Issues
+
+If you believe you have found a defect in Hugo or its documentation, use
+the GitHub [issue tracker](https://github.com/gohugoio/hugo/issues) to report the problem to the Hugo maintainers.
+If you're not sure if it's a bug or not, start by asking in the [discussion forum](https://discourse.gohugo.io).
+When reporting the issue, please provide the version of Hugo in use (`hugo version`) and your operating system.
+
+## Submitting Patches
+
+The Hugo project welcomes all contributors and contributions regardless of skill or experience level.
+If you are interested in helping with the project, we will help you with your contribution.
+Hugo is a very active project with many contributions happening daily.
+Because we want to create the best possible product for our users and the best contribution experience for our developers,
+we have a set of guidelines which ensure that all contributions are acceptable.
+The guidelines are not intended as a filter or barrier to participation.
+If you are unfamiliar with the contribution process, the Hugo team will help you and teach you how to bring your contribution in accordance with the guidelines.
+
+### Code Contribution Guidelines
+
+To make the contribution process as seamless as possible, we ask for the following:
+
+* Go ahead and fork the project and make your changes.  We encourage pull requests to allow for review and discussion of code changes.
+* When you’re ready to create a pull request, be sure to:
+    * Sign the [CLA](https://cla-assistant.io/gohugoio/hugo).
+    * Have test cases for the new code. If you have questions about how to do this, please ask in your pull request.
+    * Run `go fmt`.
+    * Add documentation if you are adding new features or changing functionality.  The docs site lives in `/docs`.
+    * Squash your commits into a single commit. `git rebase -i`. It’s okay to force update your pull request with `git push -f`.
+    * Ensure that `make check` succeeds. [Travis CI](https://travis-ci.org/gohugoio/hugo) (Linux and macOS) and [AppVeyor](https://ci.appveyor.com/project/gohugoio/hugo/branch/master) (Windows) will fail the build if `make check` fails.
+    * Follow the **Git Commit Message Guidelines** below.
+
+### Git Commit Message Guidelines
+
+This [blog article](http://chris.beams.io/posts/git-commit/) is a good resource for learning how to write good commit messages,
+the most important part being that each commit message should have a title/subject in imperative mood starting with a capital letter and no trailing period:
+*"Return error on wrong use of the Paginator"*, **NOT** *"returning some error."*
+
+Also, if your commit references one or more GitHub issues, always end your commit message body with *See #1234* or *Fixes #1234*.
+Replace *1234* with the GitHub issue ID. The last example will close the issue when the commit is merged into *master*.
+
+Sometimes it makes sense to prefix the commit message with the packagename (or docs folder) all lowercased ending with a colon.
+That is fine, but the rest of the rules above apply.
+So it is "tpl: Add emojify template func", not "tpl: add emojify template func.", and "docs: Document emoji", not "doc: document emoji."
+
+Please consider to use a short and descriptive branch name, e.g. **NOT** "patch-1". It's very common but creates a naming conflict each time when a submission is pulled for a review.
+
+An example:
+
+```text
+tpl: Add custom index function
+
+Add a custom index template function that deviates from the stdlib simply by not
+returning an "index out of range" error if an array, slice or string index is
+out of range.  Instead, we just return nil values.  This should help make the
+new default function more useful for Hugo users.
+
+Fixes #1949
+```
+
+### Vendored Dependencies
+
+Hugo uses [govendor](https://github.com/kardianos/govendor) 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 since `go get` is not vendor-aware.
+You **must use govendor** to fetch and manage Hugo's dependencies.
+
+### Fetch the Sources From GitHub
+
+```
+go get github.com/kardianos/govendor
+govendor get github.com/gohugoio/hugo
+```
+
+### Using Git Remotes
+
+Due to the way Go handles package imports, the best approach for working on a
+Hugo fork is to use Git Remotes.  Here's a simple walk-through for getting
+started:
+
+1. Fetch the Hugo sources as described above.
+
+1. Change to the Hugo source directory:
+
+    ```
+    cd $HOME/go/src/github.com/gohugoio/hugo
+    ```
+
+1. Create a new branch for your changes (the branch name is arbitrary):
+
+    ```
+    git checkout -b iss1234
+    ```
+
+1. After making your changes, commit them to your new branch:
+
+    ```
+    git commit -a -v
+    ```
+
+1. Fork Hugo in GitHub.
+
+1. Add your fork as a new remote (the remote name, "fork" in this example, is arbitrary):
+
+    ```
+    git remote add fork git://github.com/USERNAME/hugo.git
+    ```
+
+1. Push the changes to your new remote:
+
+    ```
+    git push --set-upstream fork iss1234
+    ```
+
+1. You're now ready to submit a PR based upon the new branch in your forked repository.
+
+### Build Hugo with Your Changes
+
+```bash
+cd $HOME/go/src/github.com/gohugoio/hugo
+make hugo
+# or to install in $HOME/go/bin:
+make install
+```
+
+### Updating the Hugo Sources
+
+If you want to stay in sync with the Hugo repository, you can easily pull down
+the source changes, but you'll need to keep the vendored packages up-to-date as
+well.
+
+```
+git pull
+make vendor
+```
+

Dockerfile

@@ -0,0 +1,15 @@
+FROM golang:1.8-alpine
+
+ENV GOPATH /go
+ENV USER root
+
+RUN apk update && apk add git make
+
+# pre-install known dependencies before the source, so we don't redownload them whenever the source changes
+RUN go get github.com/kardianos/govendor \
+ && govendor get github.com/gohugoio/hugo
+
+COPY . $GOPATH/src/github.com/gohugoio/hugo
+
+RUN cd $GOPATH/src/github.com/gohugoio/hugo \
+ 	&& make install test

LICENSE.md

@@ -1,67 +1,194 @@
-Simple Public License (SimPL-2.0)
-=================================
+Apache License
+==============
 
-Preamble
---------
+_Version 2.0, January 2004_
+_&lt;<http://www.apache.org/licenses/>&gt;_
 
-This Simple Public License 2.0 (SimPL-2.0 for short) is a plain language
-implementation of GPL 2.0.  The words are different, but the goal is the
-same - to guarantee for all users the freedom to share and change
-software.  If anyone wonders about the meaning of the SimPL, they should
-interpret it as consistent with GPL 2.0.
+### Terms and Conditions for use, reproduction, and distribution
 
+#### 1. Definitions
 
-Simple Public License (SimPL) 2.0
-=================================
+“License” shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
 
-The SimPL applies to the software's source and object code and comes
-with any rights that I have in it (other than trademarks). You agree to
-the SimPL by copying, distributing, or making a derivative work of the
-software.
+“Licensor” shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
 
- You get the royalty free right to:
+“Legal Entity” shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, “control” means **(i)** the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or **(ii)** ownership of fifty percent (50%) or more of the
+outstanding shares, or **(iii)** beneficial ownership of such entity.
 
--   Use the software for any purpose;
--   Make derivative works of it (this is called a "Derived Work");
--   Copy and distribute it and any Derived Work.
+“You” (or “Your”) shall mean an individual or Legal Entity exercising
+permissions granted by this License.
 
-If you distribute the software or a Derived Work, you must give back to
-the community by:
+“Source” form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
 
--   Prominently noting the date of any changes you make;
--   Leaving other people's copyright notices, warranty disclaimers, and
-    license terms in place;
--   Providing the source code, build scripts, installation scripts, and
-    interface definitions in a form that is easy to get and best to
-    modify;
--   Licensing it to everyone under SimPL, or substantially similar terms
-    (such as GPL 2.0), without adding further restrictions to the rights
-    provided;
--   Conspicuously announcing that it is available under that license.
+“Object” form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
 
-There are some things that you must shoulder:
+“Work” shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
 
--   You get NO WARRANTIES. None of any kind;
--   If the software damages you in any way, you may only recover direct
-    damages up to the amount you paid for it (that is zero if you did
-    not pay anything). You may not recover any other damages, including
-    those called "consequential damages." (The state or country where
-    you live may not allow you to limit your liability in this way, so
-    this may not apply to you);
+“Derivative Works” shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
 
-The SimPL continues perpetually, except that your license rights end
-automatically if:
+“Contribution” shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+“submitted” means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as “Not a Contribution.”
 
--   You do not abide by the "give back to the community" terms (your
-    licensees get to keep their rights if they abide);
--   Anyone prevents you from distributing the software under the terms
-    of the SimPL.
+“Contributor” shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
 
-License for the License
------------------------
+#### 2. Grant of Copyright License
 
-You may do anything that you want with the SimPL text; it's a license
-form to use in any way that you find helpful.  To avoid confusion,
-however, if you change the terms in any way then you may not call your
-license the Simple Public License or the SimPL (but feel free to
-acknowledge that your license is "based on the Simple Public License").
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+#### 3. Grant of Patent License
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this License
+for that Work shall terminate as of the date such litigation is filed.
+
+#### 4. Redistribution
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+* **(a)** You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+* **(b)** You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+* **(c)** You must retain, in the Source form of any Derivative Works that You distribute,
+all copyright, patent, trademark, and attribution notices from the Source form
+of the Work, excluding those notices that do not pertain to any part of the
+Derivative Works; and
+* **(d)** If the Work includes a “NOTICE” text file as part of its distribution, then any
+Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+#### 5. Submission of Contributions
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+#### 6. Trademarks
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+#### 7. Disclaimer of Warranty
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an “AS IS” BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+#### 8. Limitation of Liability
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+#### 9. Accepting Warranty or Additional Liability
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+_END OF TERMS AND CONDITIONS_
+
+### APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets `[]` replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same “printed page” as the copyright notice for easier identification within
+third-party archives.
+
+    Copyright [yyyy] [name of copyright owner]
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.

Makefile

@@ -0,0 +1,83 @@
+# A Self-Documenting Makefile: http://marmelab.com/blog/2016/02/29/auto-documented-makefile.html
+
+PACKAGE = github.com/gohugoio/hugo
+COMMIT_HASH = `git rev-parse --short HEAD 2>/dev/null`
+BUILD_DATE = `date +%FT%T%z`
+LDFLAGS = -ldflags "-X ${PACKAGE}/hugolib.CommitHash=${COMMIT_HASH} -X ${PACKAGE}/hugolib.BuildDate=${BUILD_DATE}"
+NOGI_LDFLAGS = -ldflags "-X ${PACKAGE}/hugolib.BuildDate=${BUILD_DATE}"
+
+.PHONY: vendor docker check fmt lint test test-race vet test-cover-html help
+.DEFAULT_GOAL := help
+
+vendor: ## Install govendor and sync Hugo's vendored dependencies
+	go get github.com/kardianos/govendor
+	govendor sync ${PACKAGE}
+
+hugo: vendor ## Build hugo binary
+	go build ${LDFLAGS} ${PACKAGE}
+
+hugo-race: vendor ## Build hugo binary with race detector enabled
+	go build -race ${LDFLAGS} ${PACKAGE}
+
+install: vendor ## Install hugo binary
+	go install ${LDFLAGS} ${PACKAGE}
+
+hugo-no-gitinfo: LDFLAGS = ${NOGI_LDFLAGS}
+hugo-no-gitinfo: vendor hugo ## Build hugo without git info
+
+docker: ## Build hugo Docker container
+	docker build -t hugo .
+	docker rm -f hugo-build || true
+	docker run --name hugo-build hugo ls /go/bin
+	docker cp hugo-build:/go/bin/hugo .
+	docker rm hugo-build
+
+govendor: vendor # Deprecated: use "vendor" target
+get: vendor # Deprecated: use "vendor"
+gitinfo: hugo # Deprecated: use "hugo" target
+install-gitinfo: install # Deprecated: use "install" target
+no-git-info: hugo-no-gitinfo # Deprecated: use "hugo-no-gitinfo" target
+
+check: test-race test386 fmt vet ## Run tests and linters
+
+test386: ## Run tests in 32-bit mode
+	GOARCH=386 govendor test +local
+
+test: ## Run tests
+	govendor test +local
+
+test-race: ## Run tests with race detector
+	govendor test -race +local
+
+fmt: ## Run gofmt linter
+	@for d in `govendor list -no-status +local | sed 's/github.com.gohugoio.hugo/./'` ; do \
+		if [ "`gofmt -l $$d/*.go | tee /dev/stderr`" ]; then \
+			echo "^ improperly formatted go files" && echo && exit 1; \
+		fi \
+	done
+
+lint: ## Run golint linter
+	@for d in `govendor list -no-status +local | sed 's/github.com.gohugoio.hugo/./'` ; do \
+		if [ "`golint $$d | tee /dev/stderr`" ]; then \
+			echo "^ golint errors!" && echo && exit 1; \
+		fi \
+	done
+
+vet: ## Run go vet linter
+	@if [ "`govendor vet +local | tee /dev/stderr`" ]; then \
+		echo "^ go vet errors!" && echo && exit 1; \
+	fi
+
+test-cover-html: PACKAGES = $(shell govendor list -no-status +local | sed 's/github.com.gohugoio.hugo/./')
+test-cover-html: ## Generate test coverage report
+	echo "mode: count" > coverage-all.out
+	$(foreach pkg,$(PACKAGES),\
+		govendor test -coverprofile=coverage.out -covermode=count $(pkg);\
+		tail -n +2 coverage.out >> coverage-all.out;)
+	go tool cover -html=coverage-all.out
+
+check-vendor: ## Verify that vendored packages match git HEAD
+	@git diff-index --quiet HEAD vendor/ || (echo "check-vendor target failed: vendored packages out of sync" && echo && git diff vendor/ && exit 1)
+
+help:
+	@grep -E '^[a-zA-Z0-9_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'

README.md

@@ -1,84 +1,106 @@
-# Hugo
-A Fast and Flexible Static Site Generator built with love by [spf13](http://spf13.com) 
-and [friends](http://github.com/spf13/hugo/graphs/contributors) in Go.
+![Hugo](https://raw.githubusercontent.com/gohugoio/hugoDocs/master/static/img/hugo-logo.png)
+
+A Fast and Flexible Static Site Generator built with love by [spf13](http://spf13.com/) and [friends](https://github.com/gohugoio/hugo/graphs/contributors) in [Go][].
+
+[Website](https://gohugo.io) |
+[Forum](https://discourse.gohugo.io) |
+[Developer Chat (no support)](https://gitter.im/gohugoio/hugo) |
+[Documentation](https://gohugo.io/overview/introduction/) |
+[Installation Guide](https://gohugo.io/overview/installing/) |
+[Contribution Guide](CONTRIBUTING.md) |
+[Twitter](http://twitter.com/gohugoio)
+
+[![GoDoc](https://godoc.org/github.com/gohugoio/hugo?status.svg)](https://godoc.org/github.com/gohugoio/hugo)
+[![Linux and macOS Build Status](https://api.travis-ci.org/gohugoio/hugo.svg?branch=master&label=Linux+and+macOS+build "Linux and macOS Build Status")](https://travis-ci.org/gohugoio/hugo)
+[![Windows Build Status](https://ci.appveyor.com/api/projects/status/a5mr220vsd091kua?svg=true&label=Windows+build "Windows Build Status")](https://ci.appveyor.com/project/bep/hugo/branch/master)
+[![Dev chat at https://gitter.im/gohugoio/hugo](https://img.shields.io/badge/gitter-developer_chat-46bc99.svg)](https://gitter.im/spf13/hugo?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Go Report Card](https://goreportcard.com/badge/github.com/gohugoio/hugo)](https://goreportcard.com/report/github.com/gohugoio/hugo)
 
 ## Overview
 
-Hugo is a static site generator written in GoLang. It is optimized for
-speed, easy use and configurability. Hugo takes a directory with content and
-templates and renders them into a full html website.
+Hugo is a static HTML and CSS website generator written in [Go][].
+It is optimized for speed, easy use and configurability.
+Hugo takes a directory with content and templates and renders them into a full HTML website.
 
-Hugo makes use of markdown files with front matter for meta data.
+Hugo relies on Markdown files with front matter for meta data.
+And you can run Hugo from any directory.
+This works well for shared hosts and other systems where you don’t have a privileged account.
 
-A typical website of moderate size can be
-rendered in a fraction of a second. A good rule of thumb is that Hugo
-takes around 1 millisecond for each piece of content.
+Hugo renders a typical website of moderate size in a fraction of a second.
+A good rule of thumb is that each piece of content renders in around 1 millisecond.
 
-It is written to work well with any
-kind of website including blogs, tumbles and docs.
+Hugo is designed to work well for any kind of website including blogs, tumbles and docs.
 
-**Complete documentation is available at [Hugo Documentation](http://hugo.spf13.com).**
+#### Supported Architectures
 
-# Getting Started
+Currently, we provide pre-built Hugo binaries for Windows, Linux, FreeBSD, NetBSD and macOS (Darwin) and [Android](https://gist.github.com/bep/a0d8a26cf6b4f8bc992729b8e50b480b) for x64, i386 and ARM architectures.
 
-## Installing Hugo
+Hugo may also be compiled from source wherever the Go compiler tool chain can run, e.g. for other operating systems including DragonFly BSD, OpenBSD, Plan 9 and Solaris.
 
-Hugo is written in GoLang with support for Windows, Linux, FreeBSD and OSX.
+**Complete documentation is available at [Hugo Documentation][].**
 
-The latest release can be found at [hugo releases](https://github.com/spf13/hugo/releases).
-We currently build for Windows, Linux, FreeBSD and OS X for x64
-and 386 architectures.
+## Choose How to Install
 
-### Installing Hugo (binary)
+If you want to use Hugo as your site generator, simply install the Hugo binaries.
+The Hugo binaries have no external dependencies.
 
-Installation is very easy. Simply download the appropriate version for your
-platform from [hugo releases](https://github.com/spf13/hugo/releases).
-Once downloaded it 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.
+To contribute to the Hugo source code or documentation, you should [fork the Hugo GitHub project](https://github.com/gohugoio/hugo#fork-destination-box) and clone it to your local machine.
 
-Ideally you should install it somewhere in your path for easy use. `/usr/local/bin` 
-is the most probable location.
+Finally, you can install the Hugo source code with `go`, build the binaries yourself, and run Hugo that way.
+Building the binaries is an easy task for an experienced `go` getter.
 
-*The Hugo executible has no external dependencies.*
+### Install Hugo as Your Site Generator (Binary Install)
 
-### Installing from source
+Use the [installation instructions in the Hugo documentation](https://gohugo.io/overview/installing/).
 
-#### Dependencies
+### Build and Install the Binaries from Source (Advanced Install)
 
-* Git
-* Go 1.1+
-* Mercurial
-* Bazaar
+Add Hugo and its package dependencies to your go `src` directory.
 
-#### Clone locally (for contributors):
+    go get -v github.com/gohugoio/hugo
 
-    git clone https://github.com/spf13/hugo
-    cd hugo
-    go get
+Once the `get` completes, you should find your new `hugo` (or `hugo.exe`) executable sitting inside `$GOPATH/bin/`.
 
-Because go expects all of your libraries to be found in either $GOROOT or $GOPATH,
-it's helpful to symlink the project to one of the following paths:
+To update Hugo’s dependencies, use `go get` with the `-u` option.
 
- * ln -s /path/to/your/hugo $GOPATH/src/github.com/spf13/hugo
- * ln -s /path/to/your/hugo $GOROOT/src/pkg/github.com/spf13/hugo
+    go get -u -v github.com/gohugoio/hugo
 
-#### Get directly from Github:
+## Contributing to Hugo
 
-If you only want to build from source, it's even easier.
+For a complete guide to contributing to Hugo, see the [Contribution Guide](CONTRIBUTING.md).
 
-    go get github.com/spf13/hugo
+We welcome contributions to Hugo of any kind including documentation, themes,
+organization, tutorials, blog posts, bug reports, issues, feature requests,
+feature implementations, pull requests, answering questions on the forum,
+helping to manage issues, etc.
 
-#### Building Hugo
+The Hugo community and maintainers are [very active](https://github.com/gohugoio/hugo/pulse/monthly) and helpful, and the project benefits greatly from this activity.
 
-    cd /path/to/hugo
-    go build -o hugo main.go
-    mv hugo /usr/local/bin/
+### Asking Support Questions
 
-#### Running Hugo
+We have an active [discussion forum](https://discourse.gohugo.io) where users and developers can ask questions.
+Please don't use the GitHub issue tracker to ask questions.
 
-    cd /path/to/hugo
-    go install github.com/spf13/hugo/hugolibs
-    go run main.go
+### Reporting Issues
 
-**Complete documentation is available at [Hugo Documentation](http://hugo.spf13.com).**
+If you believe you have found a defect in Hugo or its documentation, use
+the GitHub issue tracker to report the problem to the Hugo maintainers.
+If you're not sure if it's a bug or not, start by asking in the [discussion forum](https://discourse.gohugo.io).
+When reporting the issue, please provide the version of Hugo in use (`hugo version`).
+
+### Submitting Patches
+
+The Hugo project welcomes all contributors and contributions regardless of skill or experience level.
+If you are interested in helping with the project, we will help you with your contribution.
+Hugo is a very active project with many contributions happening daily.
+Because we want to create the best possible product for our users and the best contribution experience for our developers,
+we have a set of guidelines which ensure that all contributions are acceptable.
+The guidelines are not intended as a filter or barrier to participation.
+If you are unfamiliar with the contribution process, the Hugo team will help you and teach you how to bring your contribution in accordance with the guidelines.
+
+For a complete guide to contributing code to Hugo, see the [Contribution Guide](CONTRIBUTING.md).
+
+[![Analytics](https://ga-beacon.appspot.com/UA-7131036-6/hugo/readme)](https://github.com/igrigorik/ga-beacon)
+
+[Go]: https://golang.org/
+[Hugo Documentation]: https://gohugo.io/overview/introduction/

appveyor.yml

@@ -0,0 +1,15 @@
+init:
+  - copy c:\MinGW\bin\mingw32-make.exe c:\MinGW\bin\make.exe
+  - set PATH=%PATH%;C:\MinGW\bin;%GOPATH%\bin
+  - go version
+  - go env
+
+# clones and cd's to path
+clone_folder: C:\GOPATH\src\github.com\gohugoio\hugo
+
+install:
+  - gem install asciidoctor
+  - pip install docutils
+
+build_script:
+  - make hugo-race check

bench.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+
+
+# Convenience script to
+# - For a given branch
+# - Run  benchmark tests for a given package
+# - Do the same for master
+# - then compare the two runs with benchcmp
+
+benchFilter=".*"
+
+if (( $# < 2 ));
+  then
+    echo "USAGE: ./bench.sh <git-branch> <package-to-bench> (and <benchmark filter> (regexp, optional))"
+    exit 1
+fi
+
+
+
+if [ $# -eq 3 ]; then
+  benchFilter=$3
+fi
+
+
+BRANCH=$1
+PACKAGE=$2
+
+git checkout $BRANCH
+go test -test.run=NONE -bench="$benchFilter" -test.benchmem=true ./$PACKAGE > /tmp/bench-$PACKAGE-$BRANCH.txt
+
+git checkout master
+go test -test.run=NONE -bench="$benchFilter" -test.benchmem=true ./$PACKAGE > /tmp/bench-$PACKAGE-master.txt
+
+
+benchcmp /tmp/bench-$PACKAGE-master.txt /tmp/bench-$PACKAGE-$BRANCH.txt

benchSite.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+# Send in a regexp mathing the benchmarks you want to run, i.e. './benchSite.sh "YAML"'. 
+# Note the quotes, which will be needed for more complex expressions.
+# The above will run all variations, but only for front matter YAML.
+
+echo "Running with BenchmarkSiteBuilding/${1}"
+
+go test -run="NONE" -bench="BenchmarkSiteBuilding/${1}$" -test.benchmem=true ./hugolib -memprofile mem.prof -cpuprofile cpu.prof

bufferpool/bufpool.go

@@ -0,0 +1,38 @@
+// Copyright 2015 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package bufferpool provides a pool of bytes buffers.
+package bufferpool
+
+import (
+	"bytes"
+	"sync"
+)
+
+var bufferPool = &sync.Pool{
+	New: func() interface{} {
+		return &bytes.Buffer{}
+	},
+}
+
+// GetBuffer returns a buffer from the pool.
+func GetBuffer() (buf *bytes.Buffer) {
+	return bufferPool.Get().(*bytes.Buffer)
+}
+
+// PutBuffer returns a buffer to the pool.
+// The buffer is reset before it is put back into circulation.
+func PutBuffer(buf *bytes.Buffer) {
+	buf.Reset()
+	bufferPool.Put(buf)
+}

bufferpool/bufpool_test.go

@@ -0,0 +1,27 @@
+// Copyright 2016-present The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bufferpool
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestBufferPool(t *testing.T) {
+	buff := GetBuffer()
+	buff.WriteString("do be do be do")
+	assert.Equal(t, "do be do be do", buff.String())
+	PutBuffer(buff)
+	assert.Equal(t, 0, buff.Len())
+}

cache/partitioned_lazy_cache.go

@@ -0,0 +1,80 @@
+// Copyright 2017-present The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cache
+
+import (
+	"sync"
+)
+
+// Partition represents a cache partition where Load is the callback
+// for when the partition is needed.
+type Partition struct {
+	Key  string
+	Load func() (map[string]interface{}, error)
+}
+
+type lazyPartition struct {
+	initSync sync.Once
+	cache    map[string]interface{}
+	load     func() (map[string]interface{}, error)
+}
+
+func (l *lazyPartition) init() error {
+	var err error
+	l.initSync.Do(func() {
+		var c map[string]interface{}
+		c, err = l.load()
+		l.cache = c
+	})
+
+	return err
+}
+
+// PartitionedLazyCache is a lazily loaded cache paritioned by a supplied string key.
+type PartitionedLazyCache struct {
+	partitions map[string]*lazyPartition
+}
+
+// NewPartitionedLazyCache creates a new NewPartitionedLazyCache with the supplied
+// partitions.
+func NewPartitionedLazyCache(partitions ...Partition) *PartitionedLazyCache {
+	lazyPartitions := make(map[string]*lazyPartition, len(partitions))
+	for _, partition := range partitions {
+		lazyPartitions[partition.Key] = &lazyPartition{load: partition.Load}
+	}
+	cache := &PartitionedLazyCache{partitions: lazyPartitions}
+
+	return cache
+}
+
+// Get initializes the partition if not already done so, then looks up the given
+// key in the given partition, returns nil if no value found.
+func (c *PartitionedLazyCache) Get(partition, key string) (interface{}, error) {
+	p, found := c.partitions[partition]
+
+	if !found {
+		return nil, nil
+	}
+
+	if err := p.init(); err != nil {
+		return nil, err
+	}
+
+	if v, found := p.cache[key]; found {
+		return v, nil
+	}
+
+	return nil, nil
+
+}

cache/partitioned_lazy_cache_test.go

@@ -0,0 +1,92 @@
+// Copyright 2017-present The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cache
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewPartitionedLazyCache(t *testing.T) {
+	t.Parallel()
+
+	assert := require.New(t)
+
+	p1 := Partition{
+		Key: "p1",
+		Load: func() (map[string]interface{}, error) {
+			return map[string]interface{}{
+				"p1_1":   "p1v1",
+				"p1_2":   "p1v2",
+				"p1_nil": nil,
+			}, nil
+		},
+	}
+
+	p2 := Partition{
+		Key: "p2",
+		Load: func() (map[string]interface{}, error) {
+			return map[string]interface{}{
+				"p2_1": "p2v1",
+				"p2_2": "p2v2",
+				"p2_3": "p2v3",
+			}, nil
+		},
+	}
+
+	cache := NewPartitionedLazyCache(p1, p2)
+
+	v, err := cache.Get("p1", "p1_1")
+	assert.NoError(err)
+	assert.Equal("p1v1", v)
+
+	v, err = cache.Get("p1", "p2_1")
+	assert.NoError(err)
+	assert.Nil(v)
+
+	v, err = cache.Get("p1", "p1_nil")
+	assert.NoError(err)
+	assert.Nil(v)
+
+	v, err = cache.Get("p2", "p2_3")
+	assert.NoError(err)
+	assert.Equal("p2v3", v)
+
+	v, err = cache.Get("doesnotexist", "p1_1")
+	assert.NoError(err)
+	assert.Nil(v)
+
+	v, err = cache.Get("p1", "doesnotexist")
+	assert.NoError(err)
+	assert.Nil(v)
+
+	errorP := Partition{
+		Key: "p3",
+		Load: func() (map[string]interface{}, error) {
+			return nil, errors.New("Failed")
+		},
+	}
+
+	cache = NewPartitionedLazyCache(errorP)
+
+	v, err = cache.Get("p1", "doesnotexist")
+	assert.NoError(err)
+	assert.Nil(v)
+
+	_, err = cache.Get("p3", "doesnotexist")
+	assert.Error(err)
+
+}

commands/benchmark.go

@@ -0,0 +1,112 @@
+// Copyright 2015 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"os"
+	"runtime"
+	"runtime/pprof"
+	"time"
+
+	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+var (
+	benchmarkTimes int
+	cpuProfileFile string
+	memProfileFile string
+)
+
+var benchmarkCmd = &cobra.Command{
+	Use:   "benchmark",
+	Short: "Benchmark Hugo by building a site a number of times.",
+	Long: `Hugo can build a site many times over and analyze the running process
+creating a benchmark.`,
+}
+
+func init() {
+	initHugoBuilderFlags(benchmarkCmd)
+	initBenchmarkBuildingFlags(benchmarkCmd)
+
+	benchmarkCmd.Flags().StringVar(&cpuProfileFile, "cpuprofile", "", "path/filename for the CPU profile file")
+	benchmarkCmd.Flags().StringVar(&memProfileFile, "memprofile", "", "path/filename for the memory profile file")
+	benchmarkCmd.Flags().IntVarP(&benchmarkTimes, "count", "n", 13, "number of times to build the site")
+
+	benchmarkCmd.RunE = benchmark
+}
+
+func benchmark(cmd *cobra.Command, args []string) error {
+	cfg, err := InitializeConfig(benchmarkCmd)
+	if err != nil {
+		return err
+	}
+
+	c, err := newCommandeer(cfg)
+	if err != nil {
+		return err
+	}
+
+	var memProf *os.File
+	if memProfileFile != "" {
+		memProf, err = os.Create(memProfileFile)
+		if err != nil {
+			return err
+		}
+	}
+
+	var cpuProf *os.File
+	if cpuProfileFile != "" {
+		cpuProf, err = os.Create(cpuProfileFile)
+		if err != nil {
+			return err
+		}
+	}
+
+	var memStats runtime.MemStats
+	runtime.ReadMemStats(&memStats)
+	memAllocated := memStats.TotalAlloc
+	mallocs := memStats.Mallocs
+	if cpuProf != nil {
+		pprof.StartCPUProfile(cpuProf)
+	}
+
+	t := time.Now()
+	for i := 0; i < benchmarkTimes; i++ {
+		if err = c.resetAndBuildSites(false); err != nil {
+			return err
+		}
+	}
+	totalTime := time.Since(t)
+
+	if memProf != nil {
+		pprof.WriteHeapProfile(memProf)
+		memProf.Close()
+	}
+	if cpuProf != nil {
+		pprof.StopCPUProfile()
+		cpuProf.Close()
+	}
+
+	runtime.ReadMemStats(&memStats)
+	totalMemAllocated := memStats.TotalAlloc - memAllocated
+	totalMallocs := memStats.Mallocs - mallocs
+
+	jww.FEEDBACK.Println()
+	jww.FEEDBACK.Printf("Average time per operation: %vms\n", int(1000*totalTime.Seconds()/float64(benchmarkTimes)))
+	jww.FEEDBACK.Printf("Average memory allocated per operation: %vkB\n", totalMemAllocated/uint64(benchmarkTimes)/1024)
+	jww.FEEDBACK.Printf("Average allocations per operation: %v\n", totalMallocs/uint64(benchmarkTimes))
+
+	return nil
+}

commands/check.go

@@ -0,0 +1,23 @@
+// Copyright 2015 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"github.com/spf13/cobra"
+)
+
+var checkCmd = &cobra.Command{
+	Use:   "check",
+	Short: "Contains some verification checks",
+}

commands/commandeer.go

@@ -0,0 +1,62 @@
+// Copyright 2017 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"github.com/gohugoio/hugo/deps"
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugofs"
+)
+
+type commandeer struct {
+	*deps.DepsCfg
+	pathSpec   *helpers.PathSpec
+	configured bool
+}
+
+func (c *commandeer) Set(key string, value interface{}) {
+	if c.configured {
+		panic("commandeer cannot be changed")
+	}
+	c.Cfg.Set(key, value)
+}
+
+// PathSpec lazily creates a new PathSpec, as all the paths must
+// be configured before it is created.
+func (c *commandeer) PathSpec() *helpers.PathSpec {
+	c.configured = true
+	return c.pathSpec
+}
+
+func (c *commandeer) initFs(fs *hugofs.Fs) error {
+	c.DepsCfg.Fs = fs
+	ps, err := helpers.NewPathSpec(fs, c.Cfg)
+	if err != nil {
+		return err
+	}
+	c.pathSpec = ps
+	return nil
+}
+
+func newCommandeer(cfg *deps.DepsCfg) (*commandeer, error) {
+	l := cfg.Language
+	if l == nil {
+		l = helpers.NewDefaultLanguage(cfg.Cfg)
+	}
+	ps, err := helpers.NewPathSpec(cfg.Fs, l)
+	if err != nil {
+		return nil, err
+	}
+	return &commandeer{DepsCfg: cfg, pathSpec: ps}, nil
+}

commands/convert.go

@@ -0,0 +1,158 @@
+// Copyright 2015 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"errors"
+	"fmt"
+	"path/filepath"
+	"time"
+
+	"github.com/gohugoio/hugo/hugolib"
+	"github.com/gohugoio/hugo/parser"
+	"github.com/spf13/cast"
+	"github.com/spf13/cobra"
+)
+
+var outputDir string
+var unsafe bool
+
+var convertCmd = &cobra.Command{
+	Use:   "convert",
+	Short: "Convert your content to different formats",
+	Long: `Convert your content (e.g. front matter) to different formats.
+
+See convert's subcommands toJSON, toTOML and toYAML for more information.`,
+	RunE: nil,
+}
+
+var toJSONCmd = &cobra.Command{
+	Use:   "toJSON",
+	Short: "Convert front matter to JSON",
+	Long: `toJSON converts all front matter in the content directory
+to use JSON for the front matter.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return convertContents(rune([]byte(parser.JSONLead)[0]))
+	},
+}
+
+var toTOMLCmd = &cobra.Command{
+	Use:   "toTOML",
+	Short: "Convert front matter to TOML",
+	Long: `toTOML converts all front matter in the content directory
+to use TOML for the front matter.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return convertContents(rune([]byte(parser.TOMLLead)[0]))
+	},
+}
+
+var toYAMLCmd = &cobra.Command{
+	Use:   "toYAML",
+	Short: "Convert front matter to YAML",
+	Long: `toYAML converts all front matter in the content directory
+to use YAML for the front matter.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return convertContents(rune([]byte(parser.YAMLLead)[0]))
+	},
+}
+
+func init() {
+	convertCmd.AddCommand(toJSONCmd)
+	convertCmd.AddCommand(toTOMLCmd)
+	convertCmd.AddCommand(toYAMLCmd)
+	convertCmd.PersistentFlags().StringVarP(&outputDir, "output", "o", "", "filesystem path to write files to")
+	convertCmd.PersistentFlags().StringVarP(&source, "source", "s", "", "filesystem path to read files relative from")
+	convertCmd.PersistentFlags().BoolVar(&unsafe, "unsafe", false, "enable less safe operations, please backup first")
+	convertCmd.PersistentFlags().SetAnnotation("source", cobra.BashCompSubdirsInDir, []string{})
+}
+
+func convertContents(mark rune) error {
+	cfg, err := InitializeConfig()
+	if err != nil {
+		return err
+	}
+
+	h, err := hugolib.NewHugoSites(*cfg)
+	if err != nil {
+		return err
+	}
+
+	site := h.Sites[0]
+
+	if err = site.Initialise(); err != nil {
+		return err
+	}
+
+	if site.Source == nil {
+		panic("site.Source not set")
+	}
+	if len(site.Source.Files()) < 1 {
+		return errors.New("No source files found")
+	}
+
+	contentDir := site.PathSpec.AbsPathify(site.Cfg.GetString("contentDir"))
+	site.Log.FEEDBACK.Println("processing", len(site.Source.Files()), "content files")
+	for _, file := range site.Source.Files() {
+		site.Log.INFO.Println("Attempting to convert", file.LogicalName())
+		page, err := site.NewPage(file.LogicalName())
+		if err != nil {
+			return err
+		}
+
+		psr, err := parser.ReadFrom(file.Contents)
+		if err != nil {
+			site.Log.ERROR.Println("Error processing file:", file.Path())
+			return err
+		}
+		metadata, err := psr.Metadata()
+		if err != nil {
+			site.Log.ERROR.Println("Error processing file:", file.Path())
+			return err
+		}
+
+		// better handling of dates in formats that don't have support for them
+		if mark == parser.FormatToLeadRune("json") || mark == parser.FormatToLeadRune("yaml") || mark == parser.FormatToLeadRune("toml") {
+			newMetadata := cast.ToStringMap(metadata)
+			for k, v := range newMetadata {
+				switch vv := v.(type) {
+				case time.Time:
+					newMetadata[k] = vv.Format(time.RFC3339)
+				}
+			}
+			metadata = newMetadata
+		}
+
+		page.SetDir(filepath.Join(contentDir, file.Dir()))
+		page.SetSourceContent(psr.Content())
+		if err = page.SetSourceMetaData(metadata, mark); err != nil {
+			site.Log.ERROR.Printf("Failed to set source metadata for file %q: %s. For more info see For more info see https://github.com/gohugoio/hugo/issues/2458", page.FullFilePath(), err)
+			continue
+		}
+
+		if outputDir != "" {
+			if err = page.SaveSourceAs(filepath.Join(outputDir, page.FullFilePath())); err != nil {
+				return fmt.Errorf("Failed to save file %q: %s", page.FullFilePath(), err)
+			}
+		} else {
+			if unsafe {
+				if err = page.SaveSource(); err != nil {
+					return fmt.Errorf("Failed to save file %q: %s", page.FullFilePath(), err)
+				}
+			} else {
+				site.Log.FEEDBACK.Println("Unsafe operation not allowed, use --unsafe or set a different output path")
+			}
+		}
+	}
+	return nil
+}

commands/env.go

@@ -0,0 +1,35 @@
+// Copyright 2016 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"runtime"
+
+	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+var envCmd = &cobra.Command{
+	Use:   "env",
+	Short: "Print Hugo version and environment info",
+	Long:  `Print Hugo version and environment info. This is useful in Hugo bug reports.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		printHugoVersion()
+		jww.FEEDBACK.Printf("GOOS=%q\n", runtime.GOOS)
+		jww.FEEDBACK.Printf("GOARCH=%q\n", runtime.GOARCH)
+		jww.FEEDBACK.Printf("GOVERSION=%q\n", runtime.Version())
+
+		return nil
+	},
+}

commands/gen.go

@@ -0,0 +1,23 @@
+// Copyright 2015 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"github.com/spf13/cobra"
+)
+
+var genCmd = &cobra.Command{
+	Use:   "gen",
+	Short: "A collection of several useful generators.",
+}

commands/genautocomplete.go

@@ -0,0 +1,70 @@
+// Copyright 2015 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+var autocompleteTarget string
+
+// bash for now (zsh and others will come)
+var autocompleteType string
+
+var genautocompleteCmd = &cobra.Command{
+	Use:   "autocomplete",
+	Short: "Generate shell autocompletion script for Hugo",
+	Long: `Generates a shell autocompletion script for Hugo.
+
+NOTE: The current version supports Bash only.
+      This should work for *nix systems with Bash installed.
+
+By default, the file is written directly to /etc/bash_completion.d
+for convenience, and the command may need superuser rights, e.g.:
+
+	$ sudo hugo gen autocomplete
+
+Add ` + "`--completionfile=/path/to/file`" + ` flag to set alternative
+file-path and name.
+
+Logout and in again to reload the completion scripts,
+or just source them in directly:
+
+	$ . /etc/bash_completion`,
+
+	RunE: func(cmd *cobra.Command, args []string) error {
+		if autocompleteType != "bash" {
+			return newUserError("Only Bash is supported for now")
+		}
+
+		err := cmd.Root().GenBashCompletionFile(autocompleteTarget)
+
+		if err != nil {
+			return err
+		}
+
+		jww.FEEDBACK.Println("Bash completion file for Hugo saved to", autocompleteTarget)
+
+		return nil
+	},
+}
+
+func init() {
+	genautocompleteCmd.PersistentFlags().StringVarP(&autocompleteTarget, "completionfile", "", "/etc/bash_completion.d/hugo.sh", "autocompletion file")
+	genautocompleteCmd.PersistentFlags().StringVarP(&autocompleteType, "type", "", "bash", "autocompletion type (currently only bash supported)")
+
+	// For bash-completion
+	genautocompleteCmd.PersistentFlags().SetAnnotation("completionfile", cobra.BashCompFilenameExt, []string{})
+}

commands/gendoc.go

@@ -0,0 +1,86 @@
+// Copyright 2016 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"fmt"
+	"path"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugofs"
+	"github.com/spf13/cobra"
+	"github.com/spf13/cobra/doc"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+const gendocFrontmatterTemplate = `---
+date: %s
+title: "%s"
+slug: %s
+url: %s
+---
+`
+
+var gendocdir string
+var gendocCmd = &cobra.Command{
+	Use:   "doc",
+	Short: "Generate Markdown documentation for the Hugo CLI.",
+	Long: `Generate Markdown documentation for the Hugo CLI.
+
+This command is, mostly, used to create up-to-date documentation
+of Hugo's command-line interface for http://gohugo.io/.
+
+It creates one Markdown file per command with front matter suitable
+for rendering in Hugo.`,
+
+	RunE: func(cmd *cobra.Command, args []string) error {
+		if !strings.HasSuffix(gendocdir, helpers.FilePathSeparator) {
+			gendocdir += helpers.FilePathSeparator
+		}
+		if found, _ := helpers.Exists(gendocdir, hugofs.Os); !found {
+			jww.FEEDBACK.Println("Directory", gendocdir, "does not exist, creating...")
+			if err := hugofs.Os.MkdirAll(gendocdir, 0777); err != nil {
+				return err
+			}
+		}
+		now := time.Now().Format(time.RFC3339)
+		prepender := func(filename string) string {
+			name := filepath.Base(filename)
+			base := strings.TrimSuffix(name, path.Ext(name))
+			url := "/commands/" + strings.ToLower(base) + "/"
+			return fmt.Sprintf(gendocFrontmatterTemplate, now, strings.Replace(base, "_", " ", -1), base, url)
+		}
+
+		linkHandler := func(name string) string {
+			base := strings.TrimSuffix(name, path.Ext(name))
+			return "/commands/" + strings.ToLower(base) + "/"
+		}
+
+		jww.FEEDBACK.Println("Generating Hugo command-line documentation in", gendocdir, "...")
+		doc.GenMarkdownTreeCustom(cmd.Root(), gendocdir, prepender, linkHandler)
+		jww.FEEDBACK.Println("Done.")
+
+		return nil
+	},
+}
+
+func init() {
+	gendocCmd.PersistentFlags().StringVar(&gendocdir, "dir", "/tmp/hugodoc/", "the directory to write the doc.")
+
+	// For bash-completion
+	gendocCmd.PersistentFlags().SetAnnotation("dir", cobra.BashCompSubdirsInDir, []string{})
+}

commands/gendocshelper.go

@@ -0,0 +1,72 @@
+// Copyright 2017-present The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/gohugoio/hugo/docshelper"
+	"github.com/spf13/cobra"
+)
+
+type genDocsHelper struct {
+	target string
+	cmd    *cobra.Command
+}
+
+func createGenDocsHelper() *genDocsHelper {
+	g := &genDocsHelper{
+		cmd: &cobra.Command{
+			Use:    "docshelper",
+			Short:  "Generate some data files for the Hugo docs.",
+			Hidden: true,
+		},
+	}
+
+	g.cmd.RunE = func(cmd *cobra.Command, args []string) error {
+		return g.generate()
+	}
+
+	// Note that ./docs is a submodule, and writing to that would be suboptimal.
+	// Let us assume that the default is a sibling project.
+	g.cmd.PersistentFlags().StringVarP(&g.target, "dir", "", "../hugoDocs/data", "data dir")
+
+	return g
+}
+
+func (g *genDocsHelper) generate() error {
+	fmt.Println("Generate docs data to", g.target)
+
+	targetFile := filepath.Join(g.target, "docs.json")
+
+	f, err := os.Create(targetFile)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	enc := json.NewEncoder(f)
+	enc.SetIndent("", "  ")
+
+	if err := enc.Encode(docshelper.DocProviders); err != nil {
+		return err
+	}
+
+	fmt.Println("Done!")
+	return nil
+
+}

commands/genman.go

@@ -0,0 +1,66 @@
+// Copyright 2016 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugofs"
+	"github.com/spf13/cobra"
+	"github.com/spf13/cobra/doc"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+var genmandir string
+var genmanCmd = &cobra.Command{
+	Use:   "man",
+	Short: "Generate man pages for the Hugo CLI",
+	Long: `This command automatically generates up-to-date man pages of Hugo's
+command-line interface.  By default, it creates the man page files
+in the "man" directory under the current directory.`,
+
+	RunE: func(cmd *cobra.Command, args []string) error {
+		header := &doc.GenManHeader{
+			Section: "1",
+			Manual:  "Hugo Manual",
+			Source:  fmt.Sprintf("Hugo %s", helpers.CurrentHugoVersion),
+		}
+		if !strings.HasSuffix(genmandir, helpers.FilePathSeparator) {
+			genmandir += helpers.FilePathSeparator
+		}
+		if found, _ := helpers.Exists(genmandir, hugofs.Os); !found {
+			jww.FEEDBACK.Println("Directory", genmandir, "does not exist, creating...")
+			if err := hugofs.Os.MkdirAll(genmandir, 0777); err != nil {
+				return err
+			}
+		}
+		cmd.Root().DisableAutoGenTag = true
+
+		jww.FEEDBACK.Println("Generating Hugo man pages in", genmandir, "...")
+		doc.GenManTree(cmd.Root(), header, genmandir)
+
+		jww.FEEDBACK.Println("Done.")
+
+		return nil
+	},
+}
+
+func init() {
+	genmanCmd.PersistentFlags().StringVar(&genmandir, "dir", "man/", "the directory to write the man pages.")
+
+	// For bash-completion
+	genmanCmd.PersistentFlags().SetAnnotation("dir", cobra.BashCompSubdirsInDir, []string{})
+}

commands/hugo_windows.go

@@ -0,0 +1,27 @@
+// Copyright 2015 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import "github.com/spf13/cobra"
+
+func init() {
+	// This message to show to Windows users if Hugo is opened from explorer.exe
+	cobra.MousetrapHelpText = `
+
+  Hugo is a command-line tool for generating static website.
+
+  You need to open cmd.exe and run Hugo from there.
+  
+  Visit http://gohugo.io/ for more information.`
+}

commands/import_jekyll.go

@@ -0,0 +1,577 @@
+// Copyright 2016 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugofs"
+	"github.com/gohugoio/hugo/hugolib"
+	"github.com/gohugoio/hugo/parser"
+	"github.com/spf13/afero"
+	"github.com/spf13/cast"
+	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+func init() {
+	importCmd.AddCommand(importJekyllCmd)
+}
+
+var importCmd = &cobra.Command{
+	Use:   "import",
+	Short: "Import your site from others.",
+	Long: `Import your site from other web site generators like Jekyll.
+
+Import requires a subcommand, e.g. ` + "`hugo import jekyll jekyll_root_path target_path`.",
+	RunE: nil,
+}
+
+var importJekyllCmd = &cobra.Command{
+	Use:   "jekyll",
+	Short: "hugo import from Jekyll",
+	Long: `hugo import from Jekyll.
+
+Import from Jekyll requires two paths, e.g. ` + "`hugo import jekyll jekyll_root_path target_path`.",
+	RunE: importFromJekyll,
+}
+
+func init() {
+	importJekyllCmd.Flags().Bool("force", false, "allow import into non-empty target directory")
+}
+
+func importFromJekyll(cmd *cobra.Command, args []string) error {
+
+	if len(args) < 2 {
+		return newUserError(`Import from Jekyll requires two paths, e.g. ` + "`hugo import jekyll jekyll_root_path target_path`.")
+	}
+
+	jekyllRoot, err := filepath.Abs(filepath.Clean(args[0]))
+	if err != nil {
+		return newUserError("Path error:", args[0])
+	}
+
+	targetDir, err := filepath.Abs(filepath.Clean(args[1]))
+	if err != nil {
+		return newUserError("Path error:", args[1])
+	}
+
+	jww.INFO.Println("Import Jekyll from:", jekyllRoot, "to:", targetDir)
+
+	if strings.HasPrefix(filepath.Dir(targetDir), jekyllRoot) {
+		return newUserError("Target path should not be inside the Jekyll root, aborting.")
+	}
+
+	forceImport, _ := cmd.Flags().GetBool("force")
+	site, err := createSiteFromJekyll(jekyllRoot, targetDir, forceImport)
+	if err != nil {
+		return err
+	}
+
+	jww.FEEDBACK.Println("Importing...")
+
+	fileCount := 0
+	callback := func(path string, fi os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if fi.IsDir() {
+			return nil
+		}
+
+		relPath, err := filepath.Rel(jekyllRoot, path)
+		if err != nil {
+			return newUserError("Get rel path error:", path)
+		}
+
+		relPath = filepath.ToSlash(relPath)
+		draft := false
+
+		switch {
+		case strings.HasPrefix(relPath, "_posts/"):
+			relPath = "content/post" + relPath[len("_posts"):]
+		case strings.HasPrefix(relPath, "_drafts/"):
+			relPath = "content/draft" + relPath[len("_drafts"):]
+			draft = true
+		default:
+			return nil
+		}
+
+		fileCount++
+		return convertJekyllPost(site, path, relPath, targetDir, draft)
+	}
+
+	err = helpers.SymbolicWalk(hugofs.Os, jekyllRoot, callback)
+
+	if err != nil {
+		return err
+	}
+	jww.FEEDBACK.Println("Congratulations!", fileCount, "post(s) imported!")
+	jww.FEEDBACK.Println("Now, start Hugo by yourself:\n" +
+		"$ git clone https://github.com/spf13/herring-cove.git " + args[1] + "/themes/herring-cove")
+	jww.FEEDBACK.Println("$ cd " + args[1] + "\n$ hugo server --theme=herring-cove")
+
+	return nil
+}
+
+// TODO: Consider calling doNewSite() instead?
+func createSiteFromJekyll(jekyllRoot, targetDir string, force bool) (*hugolib.Site, error) {
+	s, err := hugolib.NewSiteDefaultLang()
+	if err != nil {
+		return nil, err
+	}
+
+	fs := s.Fs.Source
+
+	if exists, _ := helpers.Exists(targetDir, fs); exists {
+		if isDir, _ := helpers.IsDir(targetDir, fs); !isDir {
+			return nil, errors.New("Target path \"" + targetDir + "\" already exists but not a directory")
+		}
+
+		isEmpty, _ := helpers.IsEmpty(targetDir, fs)
+
+		if !isEmpty && !force {
+			return nil, errors.New("Target path \"" + targetDir + "\" already exists and is not empty")
+		}
+	}
+
+	jekyllConfig := loadJekyllConfig(fs, jekyllRoot)
+
+	// Crude test to make sure at least one of _drafts/ and _posts/ exists
+	// and is not empty.
+	hasPostsOrDrafts := false
+	postsDir := filepath.Join(jekyllRoot, "_posts")
+	draftsDir := filepath.Join(jekyllRoot, "_drafts")
+	for _, d := range []string{postsDir, draftsDir} {
+		if exists, _ := helpers.Exists(d, fs); exists {
+			if isDir, _ := helpers.IsDir(d, fs); isDir {
+				if isEmpty, _ := helpers.IsEmpty(d, fs); !isEmpty {
+					hasPostsOrDrafts = true
+				}
+			}
+		}
+	}
+	if !hasPostsOrDrafts {
+		return nil, errors.New("Your Jekyll root contains neither posts nor drafts, aborting.")
+	}
+
+	mkdir(targetDir, "layouts")
+	mkdir(targetDir, "content")
+	mkdir(targetDir, "archetypes")
+	mkdir(targetDir, "static")
+	mkdir(targetDir, "data")
+	mkdir(targetDir, "themes")
+
+	createConfigFromJekyll(fs, targetDir, "yaml", jekyllConfig)
+
+	copyJekyllFilesAndFolders(jekyllRoot, filepath.Join(targetDir, "static"))
+
+	return s, nil
+}
+
+func loadJekyllConfig(fs afero.Fs, jekyllRoot string) map[string]interface{} {
+	path := filepath.Join(jekyllRoot, "_config.yml")
+
+	exists, err := helpers.Exists(path, fs)
+
+	if err != nil || !exists {
+		jww.WARN.Println("_config.yaml not found: Is the specified Jekyll root correct?")
+		return nil
+	}
+
+	f, err := fs.Open(path)
+	if err != nil {
+		return nil
+	}
+
+	defer f.Close()
+
+	b, err := ioutil.ReadAll(f)
+
+	if err != nil {
+		return nil
+	}
+
+	c, err := parser.HandleYAMLMetaData(b)
+
+	if err != nil {
+		return nil
+	}
+
+	return c.(map[string]interface{})
+}
+
+func createConfigFromJekyll(fs afero.Fs, inpath string, kind string, jekyllConfig map[string]interface{}) (err error) {
+	title := "My New Hugo Site"
+	baseURL := "http://example.org/"
+
+	for key, value := range jekyllConfig {
+		lowerKey := strings.ToLower(key)
+
+		switch lowerKey {
+		case "title":
+			if str, ok := value.(string); ok {
+				title = str
+			}
+
+		case "url":
+			if str, ok := value.(string); ok {
+				baseURL = str
+			}
+		}
+	}
+
+	in := map[string]interface{}{
+		"baseURL":            baseURL,
+		"title":              title,
+		"languageCode":       "en-us",
+		"disablePathToLower": true,
+	}
+	kind = parser.FormatSanitize(kind)
+
+	var buf bytes.Buffer
+	err = parser.InterfaceToConfig(in, parser.FormatToLeadRune(kind), &buf)
+	if err != nil {
+		return err
+	}
+
+	return helpers.WriteToDisk(filepath.Join(inpath, "config."+kind), &buf, fs)
+}
+
+func copyFile(source string, dest string) error {
+	sf, err := os.Open(source)
+	if err != nil {
+		return err
+	}
+	defer sf.Close()
+	df, err := os.Create(dest)
+	if err != nil {
+		return err
+	}
+	defer df.Close()
+	_, err = io.Copy(df, sf)
+	if err == nil {
+		si, err := os.Stat(source)
+		if err != nil {
+			err = os.Chmod(dest, si.Mode())
+
+			if err != nil {
+				return err
+			}
+		}
+
+	}
+	return nil
+}
+
+func copyDir(source string, dest string) error {
+	fi, err := os.Stat(source)
+	if err != nil {
+		return err
+	}
+	if !fi.IsDir() {
+		return errors.New(source + " is not a directory")
+	}
+	err = os.MkdirAll(dest, fi.Mode())
+	if err != nil {
+		return err
+	}
+	entries, err := ioutil.ReadDir(source)
+	for _, entry := range entries {
+		sfp := filepath.Join(source, entry.Name())
+		dfp := filepath.Join(dest, entry.Name())
+		if entry.IsDir() {
+			err = copyDir(sfp, dfp)
+			if err != nil {
+				jww.ERROR.Println(err)
+			}
+		} else {
+			err = copyFile(sfp, dfp)
+			if err != nil {
+				jww.ERROR.Println(err)
+			}
+		}
+
+	}
+	return nil
+}
+
+func copyJekyllFilesAndFolders(jekyllRoot string, dest string) error {
+	fi, err := os.Stat(jekyllRoot)
+	if err != nil {
+		return err
+	}
+	if !fi.IsDir() {
+		return errors.New(jekyllRoot + " is not a directory")
+	}
+	err = os.MkdirAll(dest, fi.Mode())
+	if err != nil {
+		return err
+	}
+	entries, err := ioutil.ReadDir(jekyllRoot)
+	for _, entry := range entries {
+		sfp := filepath.Join(jekyllRoot, entry.Name())
+		dfp := filepath.Join(dest, entry.Name())
+		if entry.IsDir() {
+			if entry.Name()[0] != '_' && entry.Name()[0] != '.' {
+				err = copyDir(sfp, dfp)
+				if err != nil {
+					jww.ERROR.Println(err)
+				}
+			}
+		} else {
+			lowerEntryName := strings.ToLower(entry.Name())
+			exceptSuffix := []string{".md", ".markdown", ".html", ".htm",
+				".xml", ".textile", "rakefile", "gemfile", ".lock"}
+			isExcept := false
+			for _, suffix := range exceptSuffix {
+				if strings.HasSuffix(lowerEntryName, suffix) {
+					isExcept = true
+					break
+				}
+			}
+
+			if !isExcept && entry.Name()[0] != '.' && entry.Name()[0] != '_' {
+				err = copyFile(sfp, dfp)
+				if err != nil {
+					jww.ERROR.Println(err)
+				}
+			}
+		}
+
+	}
+	return nil
+}
+
+func parseJekyllFilename(filename string) (time.Time, string, error) {
+	re := regexp.MustCompile(`(\d+-\d+-\d+)-(.+)\..*`)
+	r := re.FindAllStringSubmatch(filename, -1)
+	if len(r) == 0 {
+		return time.Now(), "", errors.New("filename not match")
+	}
+
+	postDate, err := time.Parse("2006-1-2", r[0][1])
+	if err != nil {
+		return time.Now(), "", err
+	}
+
+	postName := r[0][2]
+
+	return postDate, postName, nil
+}
+
+func convertJekyllPost(s *hugolib.Site, path, relPath, targetDir string, draft bool) error {
+	jww.TRACE.Println("Converting", path)
+
+	filename := filepath.Base(path)
+	postDate, postName, err := parseJekyllFilename(filename)
+	if err != nil {
+		jww.WARN.Printf("Failed to parse filename '%s': %s. Skipping.", filename, err)
+		return nil
+	}
+
+	jww.TRACE.Println(filename, postDate, postName)
+
+	targetFile := filepath.Join(targetDir, relPath)
+	targetParentDir := filepath.Dir(targetFile)
+	os.MkdirAll(targetParentDir, 0777)
+
+	contentBytes, err := ioutil.ReadFile(path)
+	if err != nil {
+		jww.ERROR.Println("Read file error:", path)
+		return err
+	}
+
+	psr, err := parser.ReadFrom(bytes.NewReader(contentBytes))
+	if err != nil {
+		jww.ERROR.Println("Parse file error:", path)
+		return err
+	}
+
+	metadata, err := psr.Metadata()
+	if err != nil {
+		jww.ERROR.Println("Processing file error:", path)
+		return err
+	}
+
+	newmetadata, err := convertJekyllMetaData(metadata, postName, postDate, draft)
+	if err != nil {
+		jww.ERROR.Println("Convert metadata error:", path)
+		return err
+	}
+
+	jww.TRACE.Println(newmetadata)
+	content := convertJekyllContent(newmetadata, string(psr.Content()))
+
+	page, err := s.NewPage(filename)
+	if err != nil {
+		jww.ERROR.Println("New page error", filename)
+		return err
+	}
+
+	page.SetDir(targetParentDir)
+	page.SetSourceContent([]byte(content))
+	page.SetSourceMetaData(newmetadata, parser.FormatToLeadRune("yaml"))
+	page.SaveSourceAs(targetFile)
+
+	jww.TRACE.Println("Target file:", targetFile)
+
+	return nil
+}
+
+func convertJekyllMetaData(m interface{}, postName string, postDate time.Time, draft bool) (interface{}, error) {
+	url := postDate.Format("/2006/01/02/") + postName + "/"
+
+	metadata, err := cast.ToStringMapE(m)
+	if err != nil {
+		return nil, err
+	}
+
+	if draft {
+		metadata["draft"] = true
+	}
+
+	for key, value := range metadata {
+		lowerKey := strings.ToLower(key)
+
+		switch lowerKey {
+		case "layout":
+			delete(metadata, key)
+		case "permalink":
+			if str, ok := value.(string); ok {
+				url = str
+			}
+			delete(metadata, key)
+		case "category":
+			if str, ok := value.(string); ok {
+				metadata["categories"] = []string{str}
+			}
+			delete(metadata, key)
+		case "excerpt_separator":
+			if key != lowerKey {
+				delete(metadata, key)
+				metadata[lowerKey] = value
+			}
+		case "date":
+			if str, ok := value.(string); ok {
+				re := regexp.MustCompile(`(\d+):(\d+):(\d+)`)
+				r := re.FindAllStringSubmatch(str, -1)
+				if len(r) > 0 {
+					hour, _ := strconv.Atoi(r[0][1])
+					minute, _ := strconv.Atoi(r[0][2])
+					second, _ := strconv.Atoi(r[0][3])
+					postDate = time.Date(postDate.Year(), postDate.Month(), postDate.Day(), hour, minute, second, 0, time.UTC)
+				}
+			}
+			delete(metadata, key)
+		}
+
+	}
+
+	metadata["url"] = url
+	metadata["date"] = postDate.Format(time.RFC3339)
+
+	return metadata, nil
+}
+
+func convertJekyllContent(m interface{}, content string) string {
+	metadata, _ := cast.ToStringMapE(m)
+
+	lines := strings.Split(content, "\n")
+	var resultLines []string
+	for _, line := range lines {
+		resultLines = append(resultLines, strings.Trim(line, "\r\n"))
+	}
+
+	content = strings.Join(resultLines, "\n")
+
+	excerptSep := "<!--more-->"
+	if value, ok := metadata["excerpt_separator"]; ok {
+		if str, strOk := value.(string); strOk {
+			content = strings.Replace(content, strings.TrimSpace(str), excerptSep, -1)
+		}
+	}
+
+	replaceList := []struct {
+		re      *regexp.Regexp
+		replace string
+	}{
+		{regexp.MustCompile("(?i)<!-- more -->"), "<!--more-->"},
+		{regexp.MustCompile(`\{%\s*raw\s*%\}\s*(.*?)\s*\{%\s*endraw\s*%\}`), "$1"},
+		{regexp.MustCompile(`{%\s*highlight\s*(.*?)\s*%}`), "{{< highlight $1 >}}"},
+		{regexp.MustCompile(`{%\s*endhighlight\s*%}`), "{{< / highlight >}}"},
+	}
+
+	for _, replace := range replaceList {
+		content = replace.re.ReplaceAllString(content, replace.replace)
+	}
+
+	replaceListFunc := []struct {
+		re      *regexp.Regexp
+		replace func(string) string
+	}{
+		// Octopress image tag: http://octopress.org/docs/plugins/image-tag/
+		{regexp.MustCompile(`{%\s+img\s*(.*?)\s*%}`), replaceImageTag},
+	}
+
+	for _, replace := range replaceListFunc {
+		content = replace.re.ReplaceAllStringFunc(content, replace.replace)
+	}
+
+	return content
+}
+
+func replaceImageTag(match string) string {
+	r := regexp.MustCompile(`{%\s+img\s*(\p{L}*)\s+([\S]*/[\S]+)\s+(\d*)\s*(\d*)\s*(.*?)\s*%}`)
+	result := bytes.NewBufferString("{{< figure ")
+	parts := r.FindStringSubmatch(match)
+	// Index 0 is the entire string, ignore
+	replaceOptionalPart(result, "class", parts[1])
+	replaceOptionalPart(result, "src", parts[2])
+	replaceOptionalPart(result, "width", parts[3])
+	replaceOptionalPart(result, "height", parts[4])
+	// title + alt
+	part := parts[5]
+	if len(part) > 0 {
+		splits := strings.Split(part, "'")
+		lenSplits := len(splits)
+		if lenSplits == 1 {
+			replaceOptionalPart(result, "title", splits[0])
+		} else if lenSplits == 3 {
+			replaceOptionalPart(result, "title", splits[1])
+		} else if lenSplits == 5 {
+			replaceOptionalPart(result, "title", splits[1])
+			replaceOptionalPart(result, "alt", splits[3])
+		}
+	}
+	result.WriteString(">}}")
+	return result.String()
+
+}
+func replaceOptionalPart(buffer *bytes.Buffer, partName string, part string) {
+	if len(part) > 0 {
+		buffer.WriteString(partName + "=\"" + part + "\" ")
+	}
+}

commands/import_jekyll_test.go

@@ -0,0 +1,126 @@
+// Copyright 2015 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"encoding/json"
+	"github.com/stretchr/testify/assert"
+	"testing"
+	"time"
+)
+
+func TestParseJekyllFilename(t *testing.T) {
+	filenameArray := []string{
+		"2015-01-02-test.md",
+		"2012-03-15-中文.markup",
+	}
+
+	expectResult := []struct {
+		postDate time.Time
+		postName string
+	}{
+		{time.Date(2015, time.January, 2, 0, 0, 0, 0, time.UTC), "test"},
+		{time.Date(2012, time.March, 15, 0, 0, 0, 0, time.UTC), "中文"},
+	}
+
+	for i, filename := range filenameArray {
+		postDate, postName, err := parseJekyllFilename(filename)
+		assert.Equal(t, err, nil)
+		assert.Equal(t, expectResult[i].postDate.Format("2006-01-02"), postDate.Format("2006-01-02"))
+		assert.Equal(t, expectResult[i].postName, postName)
+	}
+}
+
+func TestConvertJekyllMetadata(t *testing.T) {
+	testDataList := []struct {
+		metadata interface{}
+		postName string
+		postDate time.Time
+		draft    bool
+		expect   string
+	}{
+		{map[interface{}]interface{}{}, "testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
+			`{"date":"2015-10-01T00:00:00Z","url":"/2015/10/01/testPost/"}`},
+		{map[interface{}]interface{}{}, "testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), true,
+			`{"date":"2015-10-01T00:00:00Z","draft":true,"url":"/2015/10/01/testPost/"}`},
+		{map[interface{}]interface{}{"Permalink": "/permalink.html", "layout": "post"},
+			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
+			`{"date":"2015-10-01T00:00:00Z","url":"/permalink.html"}`},
+		{map[interface{}]interface{}{"permalink": "/permalink.html"},
+			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
+			`{"date":"2015-10-01T00:00:00Z","url":"/permalink.html"}`},
+		{map[interface{}]interface{}{"category": nil, "permalink": 123},
+			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
+			`{"date":"2015-10-01T00:00:00Z","url":"/2015/10/01/testPost/"}`},
+		{map[interface{}]interface{}{"Excerpt_Separator": "sep"},
+			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
+			`{"date":"2015-10-01T00:00:00Z","excerpt_separator":"sep","url":"/2015/10/01/testPost/"}`},
+		{map[interface{}]interface{}{"category": "book", "layout": "post", "Others": "Goods", "Date": "2015-10-01 12:13:11"},
+			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
+			`{"Others":"Goods","categories":["book"],"date":"2015-10-01T12:13:11Z","url":"/2015/10/01/testPost/"}`},
+	}
+
+	for _, data := range testDataList {
+		result, err := convertJekyllMetaData(data.metadata, data.postName, data.postDate, data.draft)
+		assert.Equal(t, nil, err)
+		jsonResult, err := json.Marshal(result)
+		assert.Equal(t, nil, err)
+		assert.Equal(t, data.expect, string(jsonResult))
+	}
+}
+
+func TestConvertJekyllContent(t *testing.T) {
+	testDataList := []struct {
+		metadata interface{}
+		content  string
+		expect   string
+	}{
+		{map[interface{}]interface{}{},
+			`Test content\n<!-- more -->\npart2 content`, `Test content\n<!--more-->\npart2 content`},
+		{map[interface{}]interface{}{},
+			`Test content\n<!-- More -->\npart2 content`, `Test content\n<!--more-->\npart2 content`},
+		{map[interface{}]interface{}{"excerpt_separator": "<!--sep-->"},
+			`Test content\n<!--sep-->\npart2 content`, `Test content\n<!--more-->\npart2 content`},
+		{map[interface{}]interface{}{}, "{% raw %}text{% endraw %}", "text"},
+		{map[interface{}]interface{}{}, "{%raw%} text2 {%endraw %}", "text2"},
+		{map[interface{}]interface{}{},
+			"{% highlight go %}\nvar s int\n{% endhighlight %}",
+			"{{< highlight go >}}\nvar s int\n{{< / highlight >}}"},
+
+		// Octopress image tag
+		{map[interface{}]interface{}{},
+			"{% img http://placekitten.com/890/280 %}",
+			"{{< figure src=\"http://placekitten.com/890/280\" >}}"},
+		{map[interface{}]interface{}{},
+			"{% img left http://placekitten.com/320/250 Place Kitten #2 %}",
+			"{{< figure class=\"left\" src=\"http://placekitten.com/320/250\" title=\"Place Kitten #2\" >}}"},
+		{map[interface{}]interface{}{},
+			"{% img right http://placekitten.com/300/500 150 250 'Place Kitten #3' %}",
+			"{{< figure class=\"right\" src=\"http://placekitten.com/300/500\" width=\"150\" height=\"250\" title=\"Place Kitten #3\" >}}"},
+		{map[interface{}]interface{}{},
+			"{% img right http://placekitten.com/300/500 150 250 'Place Kitten #4' 'An image of a very cute kitten' %}",
+			"{{< figure class=\"right\" src=\"http://placekitten.com/300/500\" width=\"150\" height=\"250\" title=\"Place Kitten #4\" alt=\"An image of a very cute kitten\" >}}"},
+		{map[interface{}]interface{}{},
+			"{% img http://placekitten.com/300/500 150 250 'Place Kitten #4' 'An image of a very cute kitten' %}",
+			"{{< figure src=\"http://placekitten.com/300/500\" width=\"150\" height=\"250\" title=\"Place Kitten #4\" alt=\"An image of a very cute kitten\" >}}"},
+		{map[interface{}]interface{}{},
+			"{% img right /placekitten/300/500 'Place Kitten #4' 'An image of a very cute kitten' %}",
+			"{{< figure class=\"right\" src=\"/placekitten/300/500\" title=\"Place Kitten #4\" alt=\"An image of a very cute kitten\" >}}"},
+	}
+
+	for _, data := range testDataList {
+		result := convertJekyllContent(data.metadata, data.content)
+		assert.Equal(t, data.expect, result)
+	}
+}

commands/limit_darwin.go

@@ -0,0 +1,85 @@
+// Copyright 2015 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Copyright 2015 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"syscall"
+
+	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+func init() {
+	checkCmd.AddCommand(limit)
+}
+
+var limit = &cobra.Command{
+	Use:   "ulimit",
+	Short: "Check system ulimit settings",
+	Long: `Hugo will inspect the current ulimit settings on the system.
+This is primarily to ensure that Hugo can watch enough files on some OSs`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		var rLimit syscall.Rlimit
+		err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rLimit)
+		if err != nil {
+			return newSystemError("Error Getting Rlimit ", err)
+		}
+
+		jww.FEEDBACK.Println("Current rLimit:", rLimit)
+
+		jww.FEEDBACK.Println("Attempting to increase limit")
+		rLimit.Max = 999999
+		rLimit.Cur = 999999
+		err = syscall.Setrlimit(syscall.RLIMIT_NOFILE, &rLimit)
+		if err != nil {
+			return newSystemError("Error Setting rLimit ", err)
+		}
+		err = syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rLimit)
+		if err != nil {
+			return newSystemError("Error Getting rLimit ", err)
+		}
+		jww.FEEDBACK.Println("rLimit after change:", rLimit)
+
+		return nil
+	},
+}
+
+func tweakLimit() {
+	var rLimit syscall.Rlimit
+	err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rLimit)
+	if err != nil {
+		jww.ERROR.Println("Unable to obtain rLimit", err)
+	}
+	if rLimit.Cur < rLimit.Max {
+		rLimit.Max = 64000
+		rLimit.Cur = 64000
+		err = syscall.Setrlimit(syscall.RLIMIT_NOFILE, &rLimit)
+		if err != nil {
+			jww.WARN.Println("Unable to increase number of open files limit", err)
+		}
+	}
+}

commands/limit_others.go

@@ -0,0 +1,32 @@
+// Copyright 2015 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// +build !darwin
+// Copyright 2015 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+func tweakLimit() {
+	// nothing to do
+}

commands/list.go

@@ -0,0 +1,161 @@
+// Copyright 2015 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"path/filepath"
+
+	"github.com/gohugoio/hugo/hugolib"
+	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+func init() {
+	listCmd.AddCommand(listDraftsCmd)
+	listCmd.AddCommand(listFutureCmd)
+	listCmd.AddCommand(listExpiredCmd)
+	listCmd.PersistentFlags().StringVarP(&source, "source", "s", "", "filesystem path to read files relative from")
+	listCmd.PersistentFlags().SetAnnotation("source", cobra.BashCompSubdirsInDir, []string{})
+}
+
+var listCmd = &cobra.Command{
+	Use:   "list",
+	Short: "Listing out various types of content",
+	Long: `Listing out various types of content.
+
+List requires a subcommand, e.g. ` + "`hugo list drafts`.",
+	RunE: nil,
+}
+
+var listDraftsCmd = &cobra.Command{
+	Use:   "drafts",
+	Short: "List all drafts",
+	Long:  `List all of the drafts in your content directory.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+
+		cfg, err := InitializeConfig()
+		if err != nil {
+			return err
+		}
+
+		c, err := newCommandeer(cfg)
+		if err != nil {
+			return err
+		}
+
+		c.Set("buildDrafts", true)
+
+		sites, err := hugolib.NewHugoSites(*cfg)
+
+		if err != nil {
+			return newSystemError("Error creating sites", err)
+		}
+
+		if err := sites.Build(hugolib.BuildCfg{SkipRender: true}); err != nil {
+			return newSystemError("Error Processing Source Content", err)
+		}
+
+		for _, p := range sites.Pages() {
+			if p.IsDraft() {
+				jww.FEEDBACK.Println(filepath.Join(p.File.Dir(), p.File.LogicalName()))
+			}
+
+		}
+
+		return nil
+
+	},
+}
+
+var listFutureCmd = &cobra.Command{
+	Use:   "future",
+	Short: "List all posts dated in the future",
+	Long: `List all of the posts in your content directory which will be
+posted in the future.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+
+		cfg, err := InitializeConfig()
+		if err != nil {
+			return err
+		}
+
+		c, err := newCommandeer(cfg)
+		if err != nil {
+			return err
+		}
+
+		c.Set("buildFuture", true)
+
+		sites, err := hugolib.NewHugoSites(*cfg)
+
+		if err != nil {
+			return newSystemError("Error creating sites", err)
+		}
+
+		if err := sites.Build(hugolib.BuildCfg{SkipRender: true}); err != nil {
+			return newSystemError("Error Processing Source Content", err)
+		}
+
+		for _, p := range sites.Pages() {
+			if p.IsFuture() {
+				jww.FEEDBACK.Println(filepath.Join(p.File.Dir(), p.File.LogicalName()))
+			}
+
+		}
+
+		return nil
+
+	},
+}
+
+var listExpiredCmd = &cobra.Command{
+	Use:   "expired",
+	Short: "List all posts already expired",
+	Long: `List all of the posts in your content directory which has already
+expired.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+
+		cfg, err := InitializeConfig()
+		if err != nil {
+			return err
+		}
+
+		c, err := newCommandeer(cfg)
+		if err != nil {
+			return err
+		}
+
+		c.Set("buildExpired", true)
+
+		sites, err := hugolib.NewHugoSites(*cfg)
+
+		if err != nil {
+			return newSystemError("Error creating sites", err)
+		}
+
+		if err := sites.Build(hugolib.BuildCfg{SkipRender: true}); err != nil {
+			return newSystemError("Error Processing Source Content", err)
+		}
+
+		for _, p := range sites.Pages() {
+			if p.IsExpired() {
+				jww.FEEDBACK.Println(filepath.Join(p.File.Dir(), p.File.LogicalName()))
+			}
+
+		}
+
+		return nil
+
+	},
+}

commands/list_config.go

@@ -0,0 +1,66 @@
+// Copyright 2015 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.Print the version number of Hug
+
+package commands
+
+import (
+	"reflect"
+	"sort"
+
+	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
+	"github.com/spf13/viper"
+)
+
+var configCmd = &cobra.Command{
+	Use:   "config",
+	Short: "Print the site configuration",
+	Long:  `Print the site configuration, both default and custom settings.`,
+}
+
+func init() {
+	configCmd.RunE = printConfig
+}
+
+func printConfig(cmd *cobra.Command, args []string) error {
+	cfg, err := InitializeConfig(configCmd)
+
+	if err != nil {
+		return err
+	}
+
+	allSettings := cfg.Cfg.(*viper.Viper).AllSettings()
+
+	var separator string
+	if allSettings["metadataformat"] == "toml" {
+		separator = " = "
+	} else {
+		separator = ": "
+	}
+
+	var keys []string
+	for k := range allSettings {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	for _, k := range keys {
+		kv := reflect.ValueOf(allSettings[k])
+		if kv.Kind() == reflect.String {
+			jww.FEEDBACK.Printf("%s%s\"%+v\"\n", k, separator, allSettings[k])
+		} else {
+			jww.FEEDBACK.Printf("%s%s%+v\n", k, separator, allSettings[k])
+		}
+	}
+
+	return nil
+}

commands/new.go

@@ -0,0 +1,394 @@
+// Copyright 2016 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/gohugoio/hugo/create"
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugofs"
+	"github.com/gohugoio/hugo/hugolib"
+	"github.com/gohugoio/hugo/parser"
+	"github.com/spf13/afero"
+	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
+	"github.com/spf13/viper"
+)
+
+var (
+	configFormat  string
+	contentEditor string
+	contentType   string
+)
+
+func init() {
+	newSiteCmd.Flags().StringVarP(&configFormat, "format", "f", "toml", "config & frontmatter format")
+	newSiteCmd.Flags().Bool("force", false, "init inside non-empty directory")
+	newCmd.Flags().StringVarP(&contentType, "kind", "k", "", "content type to create")
+	newCmd.PersistentFlags().StringVarP(&source, "source", "s", "", "filesystem path to read files relative from")
+	newCmd.PersistentFlags().SetAnnotation("source", cobra.BashCompSubdirsInDir, []string{})
+	newCmd.Flags().StringVar(&contentEditor, "editor", "", "edit new content with this editor, if provided")
+
+	newCmd.AddCommand(newSiteCmd)
+	newCmd.AddCommand(newThemeCmd)
+
+}
+
+var newCmd = &cobra.Command{
+	Use:   "new [path]",
+	Short: "Create new content for your site",
+	Long: `Create a new content file and automatically set the date and title.
+It will guess which kind of file to create based on the path provided.
+
+You can also specify the kind with ` + "`-k KIND`" + `.
+
+If archetypes are provided in your theme or site, they will be used.`,
+
+	RunE: NewContent,
+}
+
+var newSiteCmd = &cobra.Command{
+	Use:   "site [path]",
+	Short: "Create a new site (skeleton)",
+	Long: `Create a new site in the provided directory.
+The new site will have the correct structure, but no content or theme yet.
+Use ` + "`hugo new [contentPath]`" + ` to create new content.`,
+	RunE: NewSite,
+}
+
+var newThemeCmd = &cobra.Command{
+	Use:   "theme [name]",
+	Short: "Create a new theme",
+	Long: `Create a new theme (skeleton) called [name] in the current directory.
+New theme is a skeleton. Please add content to the touched files. Add your
+name to the copyright line in the license and adjust the theme.toml file
+as you see fit.`,
+	RunE: NewTheme,
+}
+
+// NewContent adds new content to a Hugo site.
+func NewContent(cmd *cobra.Command, args []string) error {
+	cfg, err := InitializeConfig()
+
+	if err != nil {
+		return err
+	}
+
+	c, err := newCommandeer(cfg)
+	if err != nil {
+		return err
+	}
+
+	if cmd.Flags().Changed("editor") {
+		c.Set("newContentEditor", contentEditor)
+	}
+
+	if len(args) < 1 {
+		return newUserError("path needs to be provided")
+	}
+
+	createPath := args[0]
+
+	var kind string
+
+	createPath, kind = newContentPathSection(createPath)
+
+	if contentType != "" {
+		kind = contentType
+	}
+
+	ps, err := helpers.NewPathSpec(cfg.Fs, cfg.Cfg)
+	if err != nil {
+		return err
+	}
+
+	// If a site isn't in use in the archetype template, we can skip the build.
+	siteFactory := func(filename string, siteUsed bool) (*hugolib.Site, error) {
+		if !siteUsed {
+			return hugolib.NewSite(*cfg)
+		}
+		var s *hugolib.Site
+		if err := c.initSites(); err != nil {
+			return nil, err
+		}
+
+		if err := Hugo.Build(hugolib.BuildCfg{SkipRender: true, PrintStats: false}); err != nil {
+			return nil, err
+		}
+
+		s = Hugo.Sites[0]
+
+		if len(Hugo.Sites) > 1 {
+			// Find the best match.
+			for _, ss := range Hugo.Sites {
+				if strings.Contains(createPath, "."+ss.Language.Lang) {
+					s = ss
+					break
+				}
+			}
+		}
+		return s, nil
+	}
+
+	return create.NewContent(ps, siteFactory, kind, createPath)
+}
+
+func doNewSite(fs *hugofs.Fs, basepath string, force bool) error {
+	dirs := []string{
+		filepath.Join(basepath, "layouts"),
+		filepath.Join(basepath, "content"),
+		filepath.Join(basepath, "archetypes"),
+		filepath.Join(basepath, "static"),
+		filepath.Join(basepath, "data"),
+		filepath.Join(basepath, "themes"),
+	}
+
+	if exists, _ := helpers.Exists(basepath, fs.Source); exists {
+		if isDir, _ := helpers.IsDir(basepath, fs.Source); !isDir {
+			return errors.New(basepath + " already exists but not a directory")
+		}
+
+		isEmpty, _ := helpers.IsEmpty(basepath, fs.Source)
+
+		switch {
+		case !isEmpty && !force:
+			return errors.New(basepath + " already exists and is not empty")
+
+		case !isEmpty && force:
+			all := append(dirs, filepath.Join(basepath, "config."+configFormat))
+			for _, path := range all {
+				if exists, _ := helpers.Exists(path, fs.Source); exists {
+					return errors.New(path + " already exists")
+				}
+			}
+		}
+	}
+
+	for _, dir := range dirs {
+		if err := fs.Source.MkdirAll(dir, 0777); err != nil {
+			return fmt.Errorf("Failed to create dir: %s", err)
+		}
+	}
+
+	createConfig(fs, basepath, configFormat)
+
+	jww.FEEDBACK.Printf("Congratulations! Your new Hugo site is created in %s.\n\n", basepath)
+	jww.FEEDBACK.Println(nextStepsText())
+
+	return nil
+}
+
+func nextStepsText() string {
+	var nextStepsText bytes.Buffer
+
+	nextStepsText.WriteString(`Just a few more steps and you're ready to go:
+
+1. Download a theme into the same-named folder.
+   Choose a theme from https://themes.gohugo.io/, or
+   create your own with the "hugo new theme <THEMENAME>" command.
+2. Perhaps you want to add some content. You can add single files
+   with "hugo new `)
+
+	nextStepsText.WriteString(filepath.Join("<SECTIONNAME>", "<FILENAME>.<FORMAT>"))
+
+	nextStepsText.WriteString(`".
+3. Start the built-in live server via "hugo server".
+
+Visit https://gohugo.io/ for quickstart guide and full documentation.`)
+
+	return nextStepsText.String()
+}
+
+// NewSite creates a new Hugo site and initializes a structured Hugo directory.
+func NewSite(cmd *cobra.Command, args []string) error {
+	if len(args) < 1 {
+		return newUserError("path needs to be provided")
+	}
+
+	createpath, err := filepath.Abs(filepath.Clean(args[0]))
+	if err != nil {
+		return newUserError(err)
+	}
+
+	forceNew, _ := cmd.Flags().GetBool("force")
+
+	return doNewSite(hugofs.NewDefault(viper.New()), createpath, forceNew)
+}
+
+// NewTheme creates a new Hugo theme.
+func NewTheme(cmd *cobra.Command, args []string) error {
+	cfg, err := InitializeConfig()
+
+	if err != nil {
+		return err
+	}
+
+	if len(args) < 1 {
+		return newUserError("theme name needs to be provided")
+	}
+
+	c, err := newCommandeer(cfg)
+	if err != nil {
+		return err
+	}
+
+	createpath := c.PathSpec().AbsPathify(filepath.Join(c.Cfg.GetString("themesDir"), args[0]))
+	jww.INFO.Println("creating theme at", createpath)
+
+	if x, _ := helpers.Exists(createpath, cfg.Fs.Source); x {
+		return newUserError(createpath, "already exists")
+	}
+
+	mkdir(createpath, "layouts", "_default")
+	mkdir(createpath, "layouts", "partials")
+
+	touchFile(cfg.Fs.Source, createpath, "layouts", "index.html")
+	touchFile(cfg.Fs.Source, createpath, "layouts", "404.html")
+	touchFile(cfg.Fs.Source, createpath, "layouts", "_default", "list.html")
+	touchFile(cfg.Fs.Source, createpath, "layouts", "_default", "single.html")
+
+	touchFile(cfg.Fs.Source, createpath, "layouts", "partials", "header.html")
+	touchFile(cfg.Fs.Source, createpath, "layouts", "partials", "footer.html")
+
+	mkdir(createpath, "archetypes")
+
+	archDefault := []byte("+++\n+++\n")
+
+	err = helpers.WriteToDisk(filepath.Join(createpath, "archetypes", "default.md"), bytes.NewReader(archDefault), cfg.Fs.Source)
+	if err != nil {
+		return err
+	}
+
+	mkdir(createpath, "static", "js")
+	mkdir(createpath, "static", "css")
+
+	by := []byte(`The MIT License (MIT)
+
+Copyright (c) ` + time.Now().Format("2006") + ` YOUR_NAME_HERE
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+`)
+
+	err = helpers.WriteToDisk(filepath.Join(createpath, "LICENSE.md"), bytes.NewReader(by), cfg.Fs.Source)
+	if err != nil {
+		return err
+	}
+
+	createThemeMD(cfg.Fs, createpath)
+
+	return nil
+}
+
+func mkdir(x ...string) {
+	p := filepath.Join(x...)
+
+	err := os.MkdirAll(p, 0777) // before umask
+	if err != nil {
+		jww.FATAL.Fatalln(err)
+	}
+}
+
+func touchFile(fs afero.Fs, x ...string) {
+	inpath := filepath.Join(x...)
+	mkdir(filepath.Dir(inpath))
+	err := helpers.WriteToDisk(inpath, bytes.NewReader([]byte{}), fs)
+	if err != nil {
+		jww.FATAL.Fatalln(err)
+	}
+}
+
+func createThemeMD(fs *hugofs.Fs, inpath string) (err error) {
+
+	by := []byte(`# theme.toml template for a Hugo theme
+# See https://github.com/gohugoio/hugoThemes#themetoml for an example
+
+name = "` + strings.Title(helpers.MakeTitle(filepath.Base(inpath))) + `"
+license = "MIT"
+licenselink = "https://github.com/yourname/yourtheme/blob/master/LICENSE.md"
+description = ""
+homepage = "http://siteforthistheme.com/"
+tags = []
+features = []
+min_version = "0.24"
+
+[author]
+  name = ""
+  homepage = ""
+
+# If porting an existing theme
+[original]
+  name = ""
+  homepage = ""
+  repo = ""
+`)
+
+	err = helpers.WriteToDisk(filepath.Join(inpath, "theme.toml"), bytes.NewReader(by), fs.Source)
+	if err != nil {
+		return
+	}
+
+	return nil
+}
+
+func newContentPathSection(path string) (string, string) {
+	// Forward slashes is used in all examples. Convert if needed.
+	// Issue #1133
+	createpath := filepath.FromSlash(path)
+	var section string
+	// assume the first directory is the section (kind)
+	if strings.Contains(createpath[1:], helpers.FilePathSeparator) {
+		section = helpers.GuessSection(createpath)
+	}
+
+	return createpath, section
+}
+
+func createConfig(fs *hugofs.Fs, inpath string, kind string) (err error) {
+	in := map[string]string{
+		"baseURL":      "http://example.org/",
+		"title":        "My New Hugo Site",
+		"languageCode": "en-us",
+	}
+	kind = parser.FormatSanitize(kind)
+
+	var buf bytes.Buffer
+	err = parser.InterfaceToConfig(in, parser.FormatToLeadRune(kind), &buf)
+	if err != nil {
+		return err
+	}
+
+	return helpers.WriteToDisk(filepath.Join(inpath, "config."+kind), &buf, fs.Source)
+}

commands/new_test.go

@@ -0,0 +1,122 @@
+// Copyright 2016 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/gohugoio/hugo/hugofs"
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// Issue #1133
+func TestNewContentPathSectionWithForwardSlashes(t *testing.T) {
+	p, s := newContentPathSection("/post/new.md")
+	assert.Equal(t, filepath.FromSlash("/post/new.md"), p)
+	assert.Equal(t, "post", s)
+}
+
+func checkNewSiteInited(fs *hugofs.Fs, basepath string, t *testing.T) {
+
+	paths := []string{
+		filepath.Join(basepath, "layouts"),
+		filepath.Join(basepath, "content"),
+		filepath.Join(basepath, "archetypes"),
+		filepath.Join(basepath, "static"),
+		filepath.Join(basepath, "data"),
+		filepath.Join(basepath, "config.toml"),
+	}
+
+	for _, path := range paths {
+		_, err := fs.Source.Stat(path)
+		require.NoError(t, err)
+	}
+}
+
+func TestDoNewSite(t *testing.T) {
+	basepath := filepath.Join("base", "blog")
+	_, fs := newTestCfg()
+
+	require.NoError(t, doNewSite(fs, basepath, false))
+
+	checkNewSiteInited(fs, basepath, t)
+}
+
+func TestDoNewSite_noerror_base_exists_but_empty(t *testing.T) {
+	basepath := filepath.Join("base", "blog")
+	_, fs := newTestCfg()
+
+	require.NoError(t, fs.Source.MkdirAll(basepath, 777))
+
+	require.NoError(t, doNewSite(fs, basepath, false))
+}
+
+func TestDoNewSite_error_base_exists(t *testing.T) {
+	basepath := filepath.Join("base", "blog")
+	_, fs := newTestCfg()
+
+	require.NoError(t, fs.Source.MkdirAll(basepath, 777))
+	_, err := fs.Source.Create(filepath.Join(basepath, "foo"))
+	require.NoError(t, err)
+	// Since the directory already exists and isn't empty, expect an error
+	require.Error(t, doNewSite(fs, basepath, false))
+
+}
+
+func TestDoNewSite_force_empty_dir(t *testing.T) {
+	basepath := filepath.Join("base", "blog")
+	_, fs := newTestCfg()
+
+	require.NoError(t, fs.Source.MkdirAll(basepath, 777))
+
+	require.NoError(t, doNewSite(fs, basepath, true))
+
+	checkNewSiteInited(fs, basepath, t)
+}
+
+func TestDoNewSite_error_force_dir_inside_exists(t *testing.T) {
+	basepath := filepath.Join("base", "blog")
+	_, fs := newTestCfg()
+
+	contentPath := filepath.Join(basepath, "content")
+
+	require.NoError(t, fs.Source.MkdirAll(contentPath, 777))
+	require.Error(t, doNewSite(fs, basepath, true))
+}
+
+func TestDoNewSite_error_force_config_inside_exists(t *testing.T) {
+	basepath := filepath.Join("base", "blog")
+	_, fs := newTestCfg()
+
+	configPath := filepath.Join(basepath, "config.toml")
+	require.NoError(t, fs.Source.MkdirAll(basepath, 777))
+	_, err := fs.Source.Create(configPath)
+	require.NoError(t, err)
+
+	require.Error(t, doNewSite(fs, basepath, true))
+}
+
+func newTestCfg() (*viper.Viper, *hugofs.Fs) {
+
+	v := viper.New()
+	fs := hugofs.NewMem(v)
+
+	v.SetFs(fs.Source)
+
+	return v, fs
+
+}

commands/release.go

@@ -0,0 +1,62 @@
+// +build release
+
+// Copyright 2017-present The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"github.com/gohugoio/hugo/releaser"
+	"github.com/spf13/cobra"
+)
+
+func init() {
+	HugoCmd.AddCommand(createReleaser().cmd)
+}
+
+type releaseCommandeer struct {
+	cmd *cobra.Command
+
+	// Will be zero for main releases.
+	patchLevel int
+
+	skipPublish bool
+
+	step int
+}
+
+func createReleaser() *releaseCommandeer {
+	// Note: This is a command only meant for internal use and must be run
+	// via "go run -tags release main.go release" on the actual code base that is in the release.
+	r := &releaseCommandeer{
+		cmd: &cobra.Command{
+			Use:    "release",
+			Short:  "Release a new version of Hugo.",
+			Hidden: true,
+		},
+	}
+
+	r.cmd.RunE = func(cmd *cobra.Command, args []string) error {
+		return r.release()
+	}
+
+	r.cmd.PersistentFlags().IntVarP(&r.patchLevel, "patch", "p", 0, "patch level, defaults to 0 for main releases")
+	r.cmd.PersistentFlags().IntVarP(&r.step, "step", "s", -1, "release step, defaults to -1 for all steps.")
+	r.cmd.PersistentFlags().BoolVarP(&r.skipPublish, "skip-publish", "", false, "skip all publishing pipes of the release")
+
+	return r
+}
+
+func (r *releaseCommandeer) release() error {
+	return releaser.New(r.patchLevel, r.step, r.skipPublish).Run()
+}

commands/server.go

@@ -0,0 +1,309 @@
+// Copyright 2016 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"fmt"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"runtime"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/gohugoio/hugo/config"
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/spf13/afero"
+	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+var (
+	disableLiveReload bool
+	renderToDisk      bool
+	serverAppend      bool
+	serverInterface   string
+	serverPort        int
+	serverWatch       bool
+)
+
+var serverCmd = &cobra.Command{
+	Use:     "server",
+	Aliases: []string{"serve"},
+	Short:   "A high performance webserver",
+	Long: `Hugo provides its own webserver which builds and serves the site.
+While hugo server is high performance, it is a webserver with limited options.
+Many run it in production, but the standard behavior is for people to use it
+in development and use a more full featured server such as Nginx or Caddy.
+
+'hugo server' will avoid writing the rendered and served content to disk,
+preferring to store it in memory.
+
+By default hugo will also watch your files for any changes you make and
+automatically rebuild the site. It will then live reload any open browser pages
+and push the latest content to them. As most Hugo sites are built in a fraction
+of a second, you will be able to save and see your changes nearly instantly.`,
+	//RunE: server,
+}
+
+type filesOnlyFs struct {
+	fs http.FileSystem
+}
+
+type noDirFile struct {
+	http.File
+}
+
+func (fs filesOnlyFs) Open(name string) (http.File, error) {
+	f, err := fs.fs.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	return noDirFile{f}, nil
+}
+
+func (f noDirFile) Readdir(count int) ([]os.FileInfo, error) {
+	return nil, nil
+}
+
+func init() {
+	initHugoBuilderFlags(serverCmd)
+
+	serverCmd.Flags().IntVarP(&serverPort, "port", "p", 1313, "port on which the server will listen")
+	serverCmd.Flags().StringVarP(&serverInterface, "bind", "", "127.0.0.1", "interface to which the server will bind")
+	serverCmd.Flags().BoolVarP(&serverWatch, "watch", "w", true, "watch filesystem for changes and recreate as needed")
+	serverCmd.Flags().BoolVarP(&serverAppend, "appendPort", "", true, "append port to baseURL")
+	serverCmd.Flags().BoolVar(&disableLiveReload, "disableLiveReload", false, "watch without enabling live browser reload on rebuild")
+	serverCmd.Flags().BoolVar(&renderToDisk, "renderToDisk", false, "render to Destination path (default is render to memory & serve from there)")
+	serverCmd.Flags().String("memstats", "", "log memory usage to this file")
+	serverCmd.Flags().String("meminterval", "100ms", "interval to poll memory usage (requires --memstats), valid time units are \"ns\", \"us\" (or \"µs\"), \"ms\", \"s\", \"m\", \"h\".")
+
+	serverCmd.RunE = server
+
+}
+
+func server(cmd *cobra.Command, args []string) error {
+	cfg, err := InitializeConfig(serverCmd)
+	if err != nil {
+		return err
+	}
+
+	c, err := newCommandeer(cfg)
+	if err != nil {
+		return err
+	}
+
+	if cmd.Flags().Changed("disableLiveReload") {
+		c.Set("disableLiveReload", disableLiveReload)
+	}
+
+	if serverWatch {
+		c.Set("watch", true)
+	}
+
+	if c.Cfg.GetBool("watch") {
+		serverWatch = true
+		c.watchConfig()
+	}
+
+	l, err := net.Listen("tcp", net.JoinHostPort(serverInterface, strconv.Itoa(serverPort)))
+	if err == nil {
+		l.Close()
+	} else {
+		if serverCmd.Flags().Changed("port") {
+			// port set explicitly by user -- he/she probably meant it!
+			return newSystemErrorF("Server startup failed: %s", err)
+		}
+		jww.ERROR.Println("port", serverPort, "already in use, attempting to use an available port")
+		sp, err := helpers.FindAvailablePort()
+		if err != nil {
+			return newSystemError("Unable to find alternative port to use:", err)
+		}
+		serverPort = sp.Port
+	}
+
+	c.Set("port", serverPort)
+
+	baseURL, err = fixURL(c.Cfg, baseURL)
+	if err != nil {
+		return err
+	}
+	c.Set("baseURL", baseURL)
+
+	if err := memStats(); err != nil {
+		jww.ERROR.Println("memstats error:", err)
+	}
+
+	// If a Destination is provided via flag write to disk
+	if destination != "" {
+		renderToDisk = true
+	}
+
+	// Hugo writes the output to memory instead of the disk
+	if !renderToDisk {
+		cfg.Fs.Destination = new(afero.MemMapFs)
+		// Rendering to memoryFS, publish to Root regardless of publishDir.
+		c.Set("publishDir", "/")
+	}
+
+	if err := c.build(serverWatch); err != nil {
+		return err
+	}
+
+	for _, s := range Hugo.Sites {
+		s.RegisterMediaTypes()
+	}
+
+	// Watch runs its own server as part of the routine
+	if serverWatch {
+		watchDirs := c.getDirList()
+		baseWatchDir := c.Cfg.GetString("workingDir")
+		for i, dir := range watchDirs {
+			watchDirs[i], _ = helpers.GetRelativePath(dir, baseWatchDir)
+		}
+
+		rootWatchDirs := strings.Join(helpers.UniqueStrings(helpers.ExtractRootPaths(watchDirs)), ",")
+
+		jww.FEEDBACK.Printf("Watching for changes in %s%s{%s}\n", baseWatchDir, helpers.FilePathSeparator, rootWatchDirs)
+		err := c.newWatcher(serverPort)
+
+		if err != nil {
+			return err
+		}
+	}
+
+	c.serve(serverPort)
+
+	return nil
+}
+
+func (c *commandeer) serve(port int) {
+	if renderToDisk {
+		jww.FEEDBACK.Println("Serving pages from " + c.PathSpec().AbsPathify(c.Cfg.GetString("publishDir")))
+	} else {
+		jww.FEEDBACK.Println("Serving pages from memory")
+	}
+
+	httpFs := afero.NewHttpFs(c.Fs.Destination)
+	fs := filesOnlyFs{httpFs.Dir(c.PathSpec().AbsPathify(c.Cfg.GetString("publishDir")))}
+	fileserver := http.FileServer(fs)
+
+	// We're only interested in the path
+	u, err := url.Parse(c.Cfg.GetString("baseURL"))
+	if err != nil {
+		jww.ERROR.Fatalf("Invalid baseURL: %s", err)
+	}
+	if u.Path == "" || u.Path == "/" {
+		http.Handle("/", fileserver)
+	} else {
+		http.Handle(u.Path, http.StripPrefix(u.Path, fileserver))
+	}
+
+	jww.FEEDBACK.Printf("Web Server is available at %s (bind address %s)\n", u.String(), serverInterface)
+	jww.FEEDBACK.Println("Press Ctrl+C to stop")
+
+	endpoint := net.JoinHostPort(serverInterface, strconv.Itoa(port))
+	err = http.ListenAndServe(endpoint, nil)
+	if err != nil {
+		jww.ERROR.Printf("Error: %s\n", err.Error())
+		os.Exit(1)
+	}
+}
+
+// fixURL massages the baseURL into a form needed for serving
+// all pages correctly.
+func fixURL(cfg config.Provider, s string) (string, error) {
+	useLocalhost := false
+	if s == "" {
+		s = cfg.GetString("baseURL")
+		useLocalhost = true
+	}
+
+	if !strings.HasSuffix(s, "/") {
+		s = s + "/"
+	}
+
+	// do an initial parse of the input string
+	u, err := url.Parse(s)
+	if err != nil {
+		return "", err
+	}
+
+	// if no Host is defined, then assume that no schema or double-slash were
+	// present in the url.  Add a double-slash and make a best effort attempt.
+	if u.Host == "" && s != "/" {
+		s = "//" + s
+
+		u, err = url.Parse(s)
+		if err != nil {
+			return "", err
+		}
+	}
+
+	if useLocalhost {
+		if u.Scheme == "https" {
+			u.Scheme = "http"
+		}
+		u.Host = "localhost"
+	}
+
+	if serverAppend {
+		if strings.Contains(u.Host, ":") {
+			u.Host, _, err = net.SplitHostPort(u.Host)
+			if err != nil {
+				return "", fmt.Errorf("Failed to split baseURL hostpost: %s", err)
+			}
+		}
+		u.Host += fmt.Sprintf(":%d", serverPort)
+	}
+
+	return u.String(), nil
+}
+
+func memStats() error {
+	memstats := serverCmd.Flags().Lookup("memstats").Value.String()
+	if memstats != "" {
+		interval, err := time.ParseDuration(serverCmd.Flags().Lookup("meminterval").Value.String())
+		if err != nil {
+			interval, _ = time.ParseDuration("100ms")
+		}
+
+		fileMemStats, err := os.Create(memstats)
+		if err != nil {
+			return err
+		}
+
+		fileMemStats.WriteString("# Time\tHeapSys\tHeapAlloc\tHeapIdle\tHeapReleased\n")
+
+		go func() {
+			var stats runtime.MemStats
+
+			start := time.Now().UnixNano()
+
+			for {
+				runtime.ReadMemStats(&stats)
+				if fileMemStats != nil {
+					fileMemStats.WriteString(fmt.Sprintf("%d\t%d\t%d\t%d\t%d\n",
+						(time.Now().UnixNano()-start)/1000000, stats.HeapSys, stats.HeapAlloc, stats.HeapIdle, stats.HeapReleased))
+					time.Sleep(interval)
+				} else {
+					break
+				}
+			}
+		}()
+	}
+	return nil
+}

commands/server_test.go

@@ -0,0 +1,58 @@
+// Copyright 2015 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"testing"
+
+	"github.com/spf13/viper"
+)
+
+func TestFixURL(t *testing.T) {
+	type data struct {
+		TestName   string
+		CLIBaseURL string
+		CfgBaseURL string
+		AppendPort bool
+		Port       int
+		Result     string
+	}
+	tests := []data{
+		{"Basic http localhost", "", "http://foo.com", true, 1313, "http://localhost:1313/"},
+		{"Basic https production, http localhost", "", "https://foo.com", true, 1313, "http://localhost:1313/"},
+		{"Basic subdir", "", "http://foo.com/bar", true, 1313, "http://localhost:1313/bar/"},
+		{"Basic production", "http://foo.com", "http://foo.com", false, 80, "http://foo.com/"},
+		{"Production subdir", "http://foo.com/bar", "http://foo.com/bar", false, 80, "http://foo.com/bar/"},
+		{"No http", "", "foo.com", true, 1313, "//localhost:1313/"},
+		{"Override configured port", "", "foo.com:2020", true, 1313, "//localhost:1313/"},
+		{"No http production", "foo.com", "foo.com", false, 80, "//foo.com/"},
+		{"No http production with port", "foo.com", "foo.com", true, 2020, "//foo.com:2020/"},
+		{"No config", "", "", true, 1313, "//localhost:1313/"},
+	}
+
+	for i, test := range tests {
+		v := viper.New()
+		baseURL = test.CLIBaseURL
+		v.Set("baseURL", test.CfgBaseURL)
+		serverAppend = test.AppendPort
+		serverPort = test.Port
+		result, err := fixURL(v, baseURL)
+		if err != nil {
+			t.Errorf("Test #%d %s: unexpected error %s", i, test.TestName, err)
+		}
+		if result != test.Result {
+			t.Errorf("Test #%d %s: expected %q, got %q", i, test.TestName, test.Result, result)
+		}
+	}
+}

commands/undraft.go

@@ -0,0 +1,157 @@
+// Copyright 2015 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"bytes"
+	"errors"
+	"os"
+	"time"
+
+	"github.com/gohugoio/hugo/parser"
+	"github.com/spf13/cobra"
+)
+
+var undraftCmd = &cobra.Command{
+	Use:   "undraft path/to/content",
+	Short: "Undraft changes the content's draft status from 'True' to 'False'",
+	Long: `Undraft changes the content's draft status from 'True' to 'False'
+and updates the date to the current date and time.
+If the content's draft status is 'False', nothing is done.`,
+	RunE: Undraft,
+}
+
+// Undraft publishes the specified content by setting its draft status
+// to false and setting its publish date to now. If the specified content is
+// not a draft, it will log an error.
+func Undraft(cmd *cobra.Command, args []string) error {
+	cfg, err := InitializeConfig()
+
+	if err != nil {
+		return err
+	}
+
+	if len(args) < 1 {
+		return newUserError("a piece of content needs to be specified")
+	}
+
+	location := args[0]
+	// open the file
+	f, err := cfg.Fs.Source.Open(location)
+	if err != nil {
+		return err
+	}
+
+	// get the page from file
+	p, err := parser.ReadFrom(f)
+	f.Close()
+	if err != nil {
+		return err
+	}
+
+	w, err := undraftContent(p)
+	if err != nil {
+		return newSystemErrorF("an error occurred while undrafting %q: %s", location, err)
+	}
+
+	f, err = cfg.Fs.Source.OpenFile(location, os.O_WRONLY|os.O_TRUNC, 0644)
+	if err != nil {
+		return newSystemErrorF("%q not be undrafted due to error opening file to save changes: %q\n", location, err)
+	}
+	defer f.Close()
+	_, err = w.WriteTo(f)
+	if err != nil {
+		return newSystemErrorF("%q not be undrafted due to save error: %q\n", location, err)
+	}
+	return nil
+}
+
+// undraftContent: if the content is a draft, change its draft status to
+// 'false' and set the date to time.Now(). If the draft status is already
+// 'false', don't do anything.
+func undraftContent(p parser.Page) (bytes.Buffer, error) {
+	var buff bytes.Buffer
+	// get the metadata; easiest way to see if it's a draft
+	meta, err := p.Metadata()
+	if err != nil {
+		return buff, err
+	}
+	// since the metadata was obtainable, we can also get the key/value separator for
+	// Front Matter
+	fm := p.FrontMatter()
+	if fm == nil {
+		return buff, errors.New("Front Matter was found, nothing was finalized")
+	}
+
+	var isDraft, gotDate bool
+	var date string
+L:
+	for k, v := range meta.(map[string]interface{}) {
+		switch k {
+		case "draft":
+			if !v.(bool) {
+				return buff, errors.New("not a Draft: nothing was done")
+			}
+			isDraft = true
+			if gotDate {
+				break L
+			}
+		case "date":
+			date = v.(string) // capture the value to make replacement easier
+			gotDate = true
+			if isDraft {
+				break L
+			}
+		}
+	}
+
+	// if draft wasn't found in FrontMatter, it isn't a draft.
+	if !isDraft {
+		return buff, errors.New("not a Draft: nothing was done")
+	}
+
+	// get the front matter as bytes and split it into lines
+	var lineEnding []byte
+	fmLines := bytes.Split(fm, []byte("\n"))
+	if len(fmLines) == 1 { // if the result is only 1 element, try to split on dos line endings
+		fmLines = bytes.Split(fm, []byte("\r\n"))
+		if len(fmLines) == 1 {
+			return buff, errors.New("unable to split FrontMatter into lines")
+		}
+		lineEnding = append(lineEnding, []byte("\r\n")...)
+	} else {
+		lineEnding = append(lineEnding, []byte("\n")...)
+	}
+
+	// Write the front matter lines to the buffer, replacing as necessary
+	for _, v := range fmLines {
+		pos := bytes.Index(v, []byte("draft"))
+		if pos != -1 {
+			v = bytes.Replace(v, []byte("true"), []byte("false"), 1)
+			goto write
+		}
+		pos = bytes.Index(v, []byte("date"))
+		if pos != -1 { // if date field wasn't found, add it
+			v = bytes.Replace(v, []byte(date), []byte(time.Now().Format(time.RFC3339)), 1)
+		}
+	write:
+		buff.Write(v)
+		buff.Write(lineEnding)
+	}
+
+	// append the actual content
+	buff.Write(p.Content())
+
+	return buff, nil
+}

commands/undraft_test.go

@@ -0,0 +1,85 @@
+// Copyright 2015 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+// TODO Support Mac Encoding (\r)
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/gohugoio/hugo/parser"
+)
+
+var (
+	jsonFM      = "{\n \"date\": \"12-04-06\",\n \"title\": \"test json\"\n}"
+	jsonDraftFM = "{\n \"draft\": true,\n \"date\": \"12-04-06\",\n \"title\":\"test json\"\n}"
+	tomlFM      = "+++\n date= \"12-04-06\"\n title= \"test toml\"\n+++"
+	tomlDraftFM = "+++\n draft= true\n date= \"12-04-06\"\n title=\"test toml\"\n+++"
+	yamlFM      = "---\n date: \"12-04-06\"\n title: \"test yaml\"\n---"
+	yamlDraftFM = "---\n draft: true\n date: \"12-04-06\"\n title: \"test yaml\"\n---"
+)
+
+func TestUndraftContent(t *testing.T) {
+	tests := []struct {
+		fm          string
+		expectedErr string
+	}{
+		{jsonFM, "not a Draft: nothing was done"},
+		{jsonDraftFM, ""},
+		{tomlFM, "not a Draft: nothing was done"},
+		{tomlDraftFM, ""},
+		{yamlFM, "not a Draft: nothing was done"},
+		{yamlDraftFM, ""},
+	}
+
+	for i, test := range tests {
+		r := bytes.NewReader([]byte(test.fm))
+		p, _ := parser.ReadFrom(r)
+		res, err := undraftContent(p)
+		if test.expectedErr != "" {
+			if err == nil {
+				t.Errorf("[%d] Expected error, got none", i)
+				continue
+			}
+			if err.Error() != test.expectedErr {
+				t.Errorf("[%d] Expected %q, got %q", i, test.expectedErr, err)
+				continue
+			}
+		} else {
+			r = bytes.NewReader(res.Bytes())
+			p, _ = parser.ReadFrom(r)
+			meta, err := p.Metadata()
+			if err != nil {
+				t.Errorf("[%d] unexpected error %q", i, err)
+				continue
+			}
+			for k, v := range meta.(map[string]interface{}) {
+				if k == "draft" {
+					if v.(bool) {
+						t.Errorf("[%d] Expected %q to be \"false\", got \"true\"", i, k)
+						continue
+					}
+				}
+				if k == "date" {
+					if !strings.HasPrefix(v.(string), time.Now().Format("2006-01-02")) {
+						t.Errorf("[%d] Expected %v to start with %v", i, v.(string), time.Now().Format("2006-01-02"))
+					}
+				}
+			}
+		}
+	}
+}

commands/version.go

@@ -0,0 +1,80 @@
+// Copyright 2015 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"time"
+
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugolib"
+	"github.com/kardianos/osext"
+	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+var versionCmd = &cobra.Command{
+	Use:   "version",
+	Short: "Print the version number of Hugo",
+	Long:  `All software has versions. This is Hugo's.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		printHugoVersion()
+		return nil
+	},
+}
+
+func printHugoVersion() {
+	if hugolib.BuildDate == "" {
+		setBuildDate() // set the build date from executable's mdate
+	} else {
+		formatBuildDate() // format the compile time
+	}
+	if hugolib.CommitHash == "" {
+		jww.FEEDBACK.Printf("Hugo Static Site Generator v%s %s/%s BuildDate: %s\n", helpers.CurrentHugoVersion, runtime.GOOS, runtime.GOARCH, hugolib.BuildDate)
+	} else {
+		jww.FEEDBACK.Printf("Hugo Static Site Generator v%s-%s %s/%s BuildDate: %s\n", helpers.CurrentHugoVersion, strings.ToUpper(hugolib.CommitHash), runtime.GOOS, runtime.GOARCH, hugolib.BuildDate)
+	}
+}
+
+// setBuildDate checks the ModTime of the Hugo executable and returns it as a
+// formatted string.  This assumes that the executable name is Hugo, if it does
+// not exist, an empty string will be returned.  This is only called if the
+// hugolib.BuildDate wasn't set during compile time.
+//
+// osext is used for cross-platform.
+func setBuildDate() {
+	fname, _ := osext.Executable()
+	dir, err := filepath.Abs(filepath.Dir(fname))
+	if err != nil {
+		jww.ERROR.Println(err)
+		return
+	}
+	fi, err := os.Lstat(filepath.Join(dir, filepath.Base(fname)))
+	if err != nil {
+		jww.ERROR.Println(err)
+		return
+	}
+	t := fi.ModTime()
+	hugolib.BuildDate = t.Format(time.RFC3339)
+}
+
+// formatBuildDate formats the hugolib.BuildDate according to the value in
+// .Params.DateFormat, if it's set.
+func formatBuildDate() {
+	t, _ := time.Parse("2006-01-02T15:04:05-0700", hugolib.BuildDate)
+	hugolib.BuildDate = t.Format(time.RFC3339)
+}

config/configProvider.go

@@ -0,0 +1,26 @@
+// Copyright 2017-present The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package config
+
+// Provider provides the configuration settings for Hugo.
+type Provider interface {
+	GetString(key string) string
+	GetInt(key string) int
+	GetBool(key string) bool
+	GetStringMap(key string) map[string]interface{}
+	GetStringMapString(key string) map[string]string
+	Get(key string) interface{}
+	Set(key string, value interface{})
+	IsSet(key string) bool
+}

create/content.go

@@ -0,0 +1,125 @@
+// Copyright 2016 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package create provides functions to create new content.
+package create
+
+import (
+	"bytes"
+	"os"
+	"os/exec"
+	"path/filepath"
+
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugolib"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+// NewContent creates a new content file in the content directory based upon the
+// given kind, which is used to lookup an archetype.
+func NewContent(
+	ps *helpers.PathSpec,
+	siteFactory func(filename string, siteUsed bool) (*hugolib.Site, error), kind, targetPath string) error {
+	ext := helpers.Ext(targetPath)
+
+	jww.INFO.Printf("attempting to create %q of %q of ext %q", targetPath, kind, ext)
+
+	archetypeFilename := findArchetype(ps, kind, ext)
+
+	f, err := ps.Fs.Source.Open(archetypeFilename)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	// Building the sites can be expensive, so only do it if really needed.
+	siteUsed := false
+	if helpers.ReaderContains(f, []byte(".Site")) {
+		siteUsed = true
+	}
+
+	s, err := siteFactory(targetPath, siteUsed)
+	if err != nil {
+		return err
+	}
+
+	var content []byte
+
+	content, err = executeArcheTypeAsTemplate(s, kind, targetPath, archetypeFilename)
+	if err != nil {
+		return err
+	}
+
+	contentPath := s.PathSpec.AbsPathify(filepath.Join(s.Cfg.GetString("contentDir"), targetPath))
+
+	if err := helpers.SafeWriteToDisk(contentPath, bytes.NewReader(content), s.Fs.Source); err != nil {
+		return err
+	}
+
+	jww.FEEDBACK.Println(contentPath, "created")
+
+	editor := s.Cfg.GetString("newContentEditor")
+	if editor != "" {
+		jww.FEEDBACK.Printf("Editing %s with %q ...\n", targetPath, editor)
+
+		cmd := exec.Command(editor, contentPath)
+		cmd.Stdin = os.Stdin
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+
+		return cmd.Run()
+	}
+
+	return nil
+}
+
+// FindArchetype takes a given kind/archetype of content and returns an output
+// path for that archetype.  If no archetype is found, an empty string is
+// returned.
+func findArchetype(ps *helpers.PathSpec, kind, ext string) (outpath string) {
+	search := []string{ps.AbsPathify(ps.Cfg.GetString("archetypeDir"))}
+
+	if ps.Cfg.GetString("theme") != "" {
+		themeDir := filepath.Join(ps.AbsPathify(ps.Cfg.GetString("themesDir")+"/"+ps.Cfg.GetString("theme")), "/archetypes/")
+		if _, err := ps.Fs.Source.Stat(themeDir); os.IsNotExist(err) {
+			jww.ERROR.Printf("Unable to find archetypes directory for theme %q at %q", ps.Cfg.GetString("theme"), themeDir)
+		} else {
+			search = append(search, themeDir)
+		}
+	}
+
+	for _, x := range search {
+		// If the new content isn't in a subdirectory, kind == "".
+		// Therefore it should be excluded otherwise `is a directory`
+		// error will occur. github.com/gohugoio/hugo/issues/411
+		var pathsToCheck = []string{"default"}
+
+		if ext != "" {
+			if kind != "" {
+				pathsToCheck = append([]string{kind + ext, "default" + ext}, pathsToCheck...)
+			} else {
+				pathsToCheck = append([]string{"default" + ext}, pathsToCheck...)
+			}
+		}
+
+		for _, p := range pathsToCheck {
+			curpath := filepath.Join(x, p)
+			jww.DEBUG.Println("checking", curpath, "for archetypes")
+			if exists, _ := helpers.Exists(curpath, ps.Fs.Source); exists {
+				jww.INFO.Println("curpath: " + curpath)
+				return curpath
+			}
+		}
+	}
+
+	return ""
+}

create/content_template_handler.go

@@ -0,0 +1,114 @@
+// Copyright 2017 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package create
+
+import (
+	"bytes"
+	"fmt"
+	"time"
+
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/source"
+
+	"github.com/gohugoio/hugo/hugolib"
+	"github.com/gohugoio/hugo/tpl"
+	"github.com/spf13/afero"
+)
+
+// ArchetypeFileData represents the data available to an archetype template.
+type ArchetypeFileData struct {
+	// The archetype content type, either given as --kind option or extracted
+	// from the target path's section, i.e. "blog/mypost.md" will resolve to
+	// "blog".
+	Type string
+
+	// The current date and time as a RFC3339 formatted string, suitable for use in front matter.
+	Date string
+
+	// The Site, fully equipped with all the pages etc. Note: This will only be set if it is actually
+	// used in the archetype template. Also, if this is a multilingual setup,
+	// this site is the site that best matches the target content file, based
+	// on the presence of language code in the filename.
+	Site *hugolib.Site
+
+	// The target content file. Note that the .Content will be empty, as that
+	// has not been created yet.
+	*source.File
+}
+
+const (
+	archetypeTemplateTemplate = `+++
+title = "{{ replace .TranslationBaseName "-" " " | title }}"
+date = {{ .Date }}
+draft = true
++++`
+)
+
+func executeArcheTypeAsTemplate(s *hugolib.Site, kind, targetPath, archetypeFilename string) ([]byte, error) {
+
+	var (
+		archetypeContent  []byte
+		archetypeTemplate []byte
+		err               error
+	)
+
+	sp := source.NewSourceSpec(s.Deps.Cfg, s.Deps.Fs)
+	f := sp.NewFile(targetPath)
+
+	data := ArchetypeFileData{
+		Type: kind,
+		Date: time.Now().Format(time.RFC3339),
+		File: f,
+		Site: s,
+	}
+
+	if archetypeFilename == "" {
+		// TODO(bep) archetype revive the issue about wrong tpl funcs arg order
+		archetypeTemplate = []byte(archetypeTemplateTemplate)
+	} else {
+		archetypeTemplate, err = afero.ReadFile(s.Fs.Source, archetypeFilename)
+		if err != nil {
+			return nil, fmt.Errorf("Failed to read archetype file %q: %s", archetypeFilename, err)
+		}
+
+	}
+
+	// Reuse the Hugo template setup to get the template funcs properly set up.
+	templateHandler := s.Deps.Tmpl.(tpl.TemplateHandler)
+	templateName := "_text/" + helpers.Filename(archetypeFilename)
+	if err := templateHandler.AddTemplate(templateName, string(archetypeTemplate)); err != nil {
+		return nil, fmt.Errorf("Failed to parse archetype file %q: %s", archetypeFilename, err)
+	}
+
+	templ := templateHandler.Lookup(templateName)
+
+	var buff bytes.Buffer
+	if err := templ.Execute(&buff, data); err != nil {
+		return nil, fmt.Errorf("Failed to process archetype file %q: %s", archetypeFilename, err)
+	}
+
+	archetypeContent = buff.Bytes()
+
+	if !bytes.Contains(archetypeContent, []byte("date")) || !bytes.Contains(archetypeContent, []byte("title")) {
+		// TODO(bep) remove some time in the future.
+		s.Log.FEEDBACK.Println(fmt.Sprintf(`WARNING: date and/or title missing from archetype file %q. 
+From Hugo 0.24 this must be provided in the archetype file itself, if needed. Example:
+%s
+`, archetypeFilename, archetypeTemplateTemplate))
+
+	}
+
+	return archetypeContent, nil
+
+}

create/content_test.go

@@ -0,0 +1,175 @@
+// Copyright 2016 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package create_test
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/gohugoio/hugo/deps"
+
+	"github.com/gohugoio/hugo/hugolib"
+
+	"fmt"
+
+	"github.com/gohugoio/hugo/hugofs"
+
+	"github.com/gohugoio/hugo/create"
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/spf13/afero"
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewContent(t *testing.T) {
+	v := viper.New()
+	initViper(v)
+
+	cases := []struct {
+		kind     string
+		path     string
+		expected []string
+	}{
+		{"post", "post/sample-1.md", []string{`title = "Post Arch title"`, `test = "test1"`, "date = \"2015-01-12T19:20:04-07:00\""}},
+		{"post", "post/org-1.org", []string{`#+title: ORG-1`}},
+		{"emptydate", "post/sample-ed.md", []string{`title = "Empty Date Arch title"`, `test = "test1"`}},
+		{"stump", "stump/sample-2.md", []string{`title = "Sample 2"`}},     // no archetype file
+		{"", "sample-3.md", []string{`title = "Sample 3"`}},                // no archetype
+		{"product", "product/sample-4.md", []string{`title = "SAMPLE-4"`}}, // empty archetype front matter
+	}
+
+	for _, c := range cases {
+		cfg, fs := newTestCfg()
+		ps, err := helpers.NewPathSpec(fs, cfg)
+		require.NoError(t, err)
+		h, err := hugolib.NewHugoSites(deps.DepsCfg{Cfg: cfg, Fs: fs})
+		require.NoError(t, err)
+		require.NoError(t, initFs(fs))
+
+		siteFactory := func(filename string, siteUsed bool) (*hugolib.Site, error) {
+			return h.Sites[0], nil
+		}
+
+		require.NoError(t, create.NewContent(ps, siteFactory, c.kind, c.path))
+
+		fname := filepath.Join("content", filepath.FromSlash(c.path))
+		content := readFileFromFs(t, fs.Source, fname)
+		for i, v := range c.expected {
+			found := strings.Contains(content, v)
+			if !found {
+				t.Errorf("[%d] %q missing from output:\n%q", i, v, content)
+			}
+		}
+	}
+}
+
+func initViper(v *viper.Viper) {
+	v.Set("metaDataFormat", "toml")
+	v.Set("archetypeDir", "archetypes")
+	v.Set("contentDir", "content")
+	v.Set("themesDir", "themes")
+	v.Set("layoutDir", "layouts")
+	v.Set("i18nDir", "i18n")
+	v.Set("theme", "sample")
+}
+
+func initFs(fs *hugofs.Fs) error {
+	perm := os.FileMode(0755)
+	var err error
+
+	// create directories
+	dirs := []string{
+		"archetypes",
+		"content",
+		filepath.Join("themes", "sample", "archetypes"),
+	}
+	for _, dir := range dirs {
+		err = fs.Source.Mkdir(dir, perm)
+		if err != nil {
+			return err
+		}
+	}
+
+	// create files
+	for _, v := range []struct {
+		path    string
+		content string
+	}{
+		{
+			path:    filepath.Join("archetypes", "post.md"),
+			content: "+++\ndate = \"2015-01-12T19:20:04-07:00\"\ntitle = \"Post Arch title\"\ntest = \"test1\"\n+++\n",
+		},
+		{
+			path:    filepath.Join("archetypes", "post.org"),
+			content: "#+title: {{ .BaseFileName  | upper }}",
+		},
+		{
+			path: filepath.Join("archetypes", "product.md"),
+			content: `+++
+title = "{{ .BaseFileName  | upper }}"
++++`,
+		},
+		{
+			path:    filepath.Join("archetypes", "emptydate.md"),
+			content: "+++\ndate =\"\"\ntitle = \"Empty Date Arch title\"\ntest = \"test1\"\n+++\n",
+		},
+	} {
+		f, err := fs.Source.Create(v.path)
+		if err != nil {
+			return err
+		}
+		defer f.Close()
+
+		_, err = f.Write([]byte(v.content))
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// TODO(bep) extract common testing package with this and some others
+func readFileFromFs(t *testing.T, fs afero.Fs, filename string) string {
+	filename = filepath.FromSlash(filename)
+	b, err := afero.ReadFile(fs, filename)
+	if err != nil {
+		// Print some debug info
+		root := strings.Split(filename, helpers.FilePathSeparator)[0]
+		afero.Walk(fs, root, func(path string, info os.FileInfo, err error) error {
+			if info != nil && !info.IsDir() {
+				fmt.Println("    ", path)
+			}
+
+			return nil
+		})
+		t.Fatalf("Failed to read file: %s", err)
+	}
+	return string(b)
+}
+
+func newTestCfg() (*viper.Viper, *hugofs.Fs) {
+
+	v := viper.New()
+	fs := hugofs.NewMem(v)
+
+	v.SetFs(fs.Source)
+
+	initViper(v)
+
+	return v, fs
+
+}

deps/deps.go

@@ -0,0 +1,176 @@
+package deps
+
+import (
+	"io/ioutil"
+	"log"
+	"os"
+
+	"github.com/gohugoio/hugo/config"
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugofs"
+	"github.com/gohugoio/hugo/output"
+	"github.com/gohugoio/hugo/tpl"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+// Deps holds dependencies used by many.
+// There will be normally be only one instance of deps in play
+// at a given time, i.e. one per Site built.
+type Deps struct {
+	// The logger to use.
+	Log *jww.Notepad `json:"-"`
+
+	// The templates to use. This will usually implement the full tpl.TemplateHandler.
+	Tmpl tpl.TemplateFinder `json:"-"`
+
+	// The file systems to use.
+	Fs *hugofs.Fs `json:"-"`
+
+	// The PathSpec to use
+	*helpers.PathSpec `json:"-"`
+
+	// The ContentSpec to use
+	*helpers.ContentSpec `json:"-"`
+
+	// The configuration to use
+	Cfg config.Provider `json:"-"`
+
+	// The translation func to use
+	Translate func(translationID string, args ...interface{}) string `json:"-"`
+
+	Language *helpers.Language
+
+	// All the output formats available for the current site.
+	OutputFormatsConfig output.Formats
+
+	templateProvider ResourceProvider
+	WithTemplate     func(templ tpl.TemplateHandler) error `json:"-"`
+
+	translationProvider ResourceProvider
+}
+
+// ResourceProvider is used to create and refresh, and clone resources needed.
+type ResourceProvider interface {
+	Update(deps *Deps) error
+	Clone(deps *Deps) error
+}
+
+func (d *Deps) TemplateHandler() tpl.TemplateHandler {
+	return d.Tmpl.(tpl.TemplateHandler)
+}
+
+func (d *Deps) LoadResources() error {
+	// Note that the translations need to be loaded before the templates.
+	if err := d.translationProvider.Update(d); err != nil {
+		return err
+	}
+
+	if err := d.templateProvider.Update(d); err != nil {
+		return err
+	}
+
+	if th, ok := d.Tmpl.(tpl.TemplateHandler); ok {
+		th.PrintErrors()
+	}
+
+	return nil
+}
+
+func New(cfg DepsCfg) (*Deps, error) {
+	var (
+		logger = cfg.Logger
+		fs     = cfg.Fs
+	)
+
+	if cfg.TemplateProvider == nil {
+		panic("Must have a TemplateProvider")
+	}
+
+	if cfg.TranslationProvider == nil {
+		panic("Must have a TranslationProvider")
+	}
+
+	if cfg.Language == nil {
+		panic("Must have a Language")
+	}
+
+	if logger == nil {
+		logger = jww.NewNotepad(jww.LevelError, jww.LevelError, os.Stdout, ioutil.Discard, "", log.Ldate|log.Ltime)
+	}
+
+	if fs == nil {
+		// Default to the production file system.
+		fs = hugofs.NewDefault(cfg.Language)
+	}
+
+	ps, err := helpers.NewPathSpec(fs, cfg.Language)
+
+	if err != nil {
+		return nil, err
+	}
+
+	d := &Deps{
+		Fs:                  fs,
+		Log:                 logger,
+		templateProvider:    cfg.TemplateProvider,
+		translationProvider: cfg.TranslationProvider,
+		WithTemplate:        cfg.WithTemplate,
+		PathSpec:            ps,
+		ContentSpec:         helpers.NewContentSpec(cfg.Language),
+		Cfg:                 cfg.Language,
+		Language:            cfg.Language,
+	}
+
+	return d, nil
+}
+
+// ForLanguage creates a copy of the Deps with the language dependent
+// parts switched out.
+func (d Deps) ForLanguage(l *helpers.Language) (*Deps, error) {
+	var err error
+
+	d.PathSpec, err = helpers.NewPathSpec(d.Fs, l)
+	if err != nil {
+		return nil, err
+	}
+
+	d.ContentSpec = helpers.NewContentSpec(l)
+	d.Cfg = l
+	d.Language = l
+
+	if err := d.translationProvider.Clone(&d); err != nil {
+		return nil, err
+	}
+
+	if err := d.templateProvider.Clone(&d); err != nil {
+		return nil, err
+	}
+
+	return &d, nil
+
+}
+
+// DepsCfg contains configuration options that can be used to configure Hugo
+// on a global level, i.e. logging etc.
+// Nil values will be given default values.
+type DepsCfg struct {
+
+	// The Logger to use.
+	Logger *jww.Notepad
+
+	// The file systems to use
+	Fs *hugofs.Fs
+
+	// The language to use.
+	Language *helpers.Language
+
+	// The configuration to use.
+	Cfg config.Provider
+
+	// Template handling.
+	TemplateProvider ResourceProvider
+	WithTemplate     func(templ tpl.TemplateHandler) error
+
+	// i18n handling.
+	TranslationProvider ResourceProvider
+}

docs/config.yaml

@@ -1,4 +0,0 @@
-Indexes:
-  tag: 'tags'
-BaseUrl: 'http://localhost'
-...

docs/content/doc/configuration.md

@@ -1,58 +0,0 @@
----
-title: "Configuring Hugo"
-pubdate: "2013-07-01"
----
-
-The directory structure and templates provide the majority of the
-configuration for a site. In fact a config file isn't even needed for many websites
-since the defaults used follow commonly used patterns.
-
-Hugo expects to find the config file in the root of the source directory and
-will look there first for a config.yaml file. If none is present it will
-then look for a config.json file, followed by a config.toml file.
-
-**Please note the field names must be all lowercase**
-
-## Examples
-
-The following is an example of a yaml config file with the default values: 
-
-    ---
-    sourcedir: "content"
-    layoutdir: "layouts"
-    publishdir: "public"
-    builddrafts: false
-    indexes:
-       category: "categories"
-       tag: "tags"
-    baseurl: "http://yoursite.com/"
-    ...
-
-
-The following is an example of a json config file with the default values: 
-
-    {
-        "sourcedir": "content",
-        "layoutdir": "layouts",
-        "publishdir": "public",
-        "builddrafts": false,
-        "indexes": {
-           "category": "categories",
-           "tag": "tags"
-        },
-        "baseurl": "http://yoursite.com/"
-    }
-
-
-The following is an example of a toml config file with the default values: 
-
-    sourcedir = "content"
-    layoutdir = "layouts"
-    publishdir = "public"
-    builddrafts = false
-    baseurl = "http://yoursite.com/"
-    [indexes]
-       category = "categories"
-       tag = "tags"
-
-

docs/content/doc/contributing.md

@@ -1,44 +0,0 @@
----
-title: "Contributing to Hugo"
-Pubdate: "2013-07-01"
----
-
-We welcome all contributions. If you want to contribute, all 
-that is needed is simply fork Hugo, make changes and submit 
-a pull request. If you prefer, pick something from the roadmap
-or contact [spf13](http://spf13.com) about what may make sense 
-to do next.
-
-## Overview 
-1. Fork it from https://github.com/spf13/hugo
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
-
-
-### Clone locally (for contributors):
-
-    git clone https://github.com/spf13/hugo
-    cd hugo
-    go get
-
-Because go expects all of your libraries to be found in either 
-$GOROOT or $GOPATH, it's helpful to symlink the project to one 
-of the following paths:
-
- * ln -s /path/to/your/hugo $GOPATH/src/github.com/spf13/hugo
- * ln -s /path/to/your/hugo $GOROOT/src/pkg/github.com/spf13/hugo
-
-### Running Hugo
-
-    cd /path/to/hugo
-    go install github.com/spf13/hugo/hugolibs
-    go run main.go
-
-### Building Hugo
-
-    cd /path/to/hugo
-    go build -o hugo main.go
-    mv hugo /usr/local/bin/
-

docs/content/doc/contributors.md

@@ -1,9 +0,0 @@
----
-title: "Contributors"
-date: "2013-07-01"
----
-
-Hugo was built with love and golang by:
-
-* [spf13](https://github.com/spf13)
-

docs/content/doc/example.md

@@ -1,40 +0,0 @@
----
-title: "Example Content File"
-Pubdate: "2013-07-01"
----
-
-Somethings are better shown than explained. The following is a very basic example of a content file:
-
-**mysite/project/nitro.md  <- http://mysite.com/project/nitro.html**
-
-    ---
-    Title: "Nitro : A quick and simple profiler for golang"
-    Description": ""
-    Keywords": [ "Development", "golang", "profiling" ]
-    Tags": [ "Development", "golang", "profiling" ]
-    Pubdate": "2013-06-19"
-    Topics": [ "Development", "GoLang" ]
-    Slug": "nitro"
-    project_url": "http://github.com/spf13/nitro"
-    ---
-
-    # Nitro
-
-    Quick and easy performance analyzer library for golang.
-
-    ## Overview
-
-    Nitro is a quick and easy performance analyzer library for golang.
-    It is useful for comparing A/B against different drafts of functions
-    or different functions.
-
-    ## Implementing Nitro
-
-    Using Nitro is simple. First use go get to install the latest version
-    of the library.
-
-        $ go get github.com/spf13/nitro
-
-    Next include nitro in your application.
-
-

docs/content/doc/front-matter.md

@@ -1,82 +0,0 @@
-+++
-title = "Front Matter"
-date = "2013-07-01"
-+++
-
-The front matter is one of the features that gives Hugo it's strength. It enables
-you to include the meta data of the content right with it. Hugo supports a few 
-different formats each with their own identifying tokens. 
-
-Supported formats: <br>
-  **YAML**, identified by '\-\-\-'. <br>
-  **TOML**, indentified with '+++'.<br>
-  **JSON**, a single JSON object which is surrounded by '{' and '}' each on their own line.
-
-### YAML Example
-
-    ---
-    title: "spf13-vim 3.0 release and new website"
-    description: "spf13-vim is a cross platform distribution of vim plugins and resources for Vim."
-    tags: [ ".vimrc", "plugins", "spf13-vim", "vim" ]
-    pubdate: "2012-04-06"
-    categories:
-      - "Development"
-      - "VIM"
-    slug: "spf13-vim-3-0-release-and-new-website"
-    ---
-    Content of the file goes Here 
-
-### TOML Example
-
-    +++
-    title = "spf13-vim 3.0 release and new website"
-    description = "spf13-vim is a cross platform distribution of vim plugins and resources for Vim."
-    tags = [ ".vimrc", "plugins", "spf13-vim", "vim" ]
-    Pubdate = "2012-04-06"
-    categories = [
-      "Development",
-      "VIM"
-    ]
-    slug = "spf13-vim-3-0-release-and-new-website"
-    +++
-    Content of the file goes Here 
-
-### JSON Example
-
-    {
-    "title": "spf13-vim 3.0 release and new website",
-    "description": "spf13-vim is a cross platform distribution of vim plugins and resources for Vim.",
-    "tags": [ ".vimrc", "plugins", "spf13-vim", "vim" ],
-    "date": "2012-04-06",
-    "categories": [
-        "Development",
-        "VIM"
-    ],
-    "slug": "spf13-vim-3-0-release-and-new-website",
-    }
-    Content of the file goes Here 
-
-### Variables
-
-There are a few predefined variables that Hugo is aware of and utilizes. The user can also create
-any variable they want to. These will be placed into the `.Params` variable available to the templates.
-**Field names are case insensitive.**
-
-#### Required
-
-**title**  The title for the content. <br>
-**description** The description for the content.<br>
-**date** The date the content will be sorted by.<br>
-**indexes** These will use the field name of the plural form of the index (see tags and categories above)
-
-#### Optional
-
-**draft** If true the content will not be rendered unless `hugo` is called with -d<br>
-**type** The type of the content (will be derived from the directory automatically if unset).<br>
-**markup** (Experimental) Specify "rst" for reStructuredText (requires
-           `rst2html`,) or "md" (default) for the Markdown.<br>
-**slug** The token to appear in the tail of the url.<br>
-  *or*<br>
-**url** The full path to the content from the web root.<br>
-*If neither is present the filename will be used.*
-

docs/content/doc/indexes.md

@@ -1,183 +0,0 @@
----
-title: "Indexes"
-Pubdate: "2013-07-01"
----
-
-Hugo includes support for user defined indexes of content. In our 
-terminology an index is best thought of as tags applied to content
-but they can be used for far more than just tags. Other common
-uses would include categories, groups, series. For the purpose of 
-this document we will just use tags for our example. For a more 
-complete example see [spf13.com-hugo](http://github.com/spf13/spf13.com-hugo).
-
-## Defining Indexes for a site
-
-Indexes must be defined in the site configuration, before they
-can be used throughout the site. 
-
-Here is an example configuration in YAML that specifies two indexes.
-Notice the format is **singular key** : *plural value*. While 
-we could use an inflection library to pluralize this, they currently
-support only a few languages, so instead we've opted for user defined
-pluralization.
-
-**config.yaml**
-
-    ---
-    indexes:
-        tag: "tags"
-        topic: "topics"
-    baseurl: "http://spf13.com/"
-    title: "Steve Francia is spf13.com"
-    ---
-
-## Creating index templates
-For each index type a template needs to be provided to render the index page.
-In the case of tags, this will render the content for /tags/TAGNAME/.
-
-The template must be called the singular name of the index and placed in 
-layouts/indexes
-
-    .
-    └── layouts
-        └── indexes
-            └── category.html
-
-The template will be provided Data about the index. 
-
-### Variables
-
-The following variables are available to the index template:
-
-**.Title**  The title for the content. <br>
-**.Date** The date the content is published on.<br>
-**.Permalink** The Permanent link for this page.<br>
-**.RSSLink** Link to the indexes' rss link. <br>
-**.Data.Pages** The content that is assigned this index.<br>
-**.Data.`singular`** The index itself.<br>
-
-#### Example
-
-    {{ template "chrome/header.html" . }}
-    {{ template "chrome/subheader.html" . }}
-
-    <section id="main">
-      <div>
-       <h1 id="title">{{ .Title }}</h1>
-        {{ range .Data.Pages }}
-            {{ .Render "summary"}}
-        {{ end }}
-      </div>
-    </section>
-
-    <aside id="meta"> </aside>
-
-    {{ template "chrome/footer.html" }}
-
-
-## Assigning indexes to content
-
-Once an index is defined at the site level, any piece of content
-can be assigned to it regardless of content type or section.
-
-Assigning content to an index is done in the front matter.
-Simply create a variable with the *plural* name of the index
-and assign all keys you want this content to match against. 
-
-**Index values are case insensitive**
-
-#### Example
-    {
-        "Title": "Hugo: A fast and flexible static site generator",
-        "Tags": [
-            "Development",
-            "golang",
-            "Blogging"
-        ],
-        "Slug": "hugo",
-        "project_url": "http://github.com/spf13/hugo"
-    }
-
-
-## Displaying indexes within content
-
-Within your content templates you may wish to display 
-the indexes that that piece of content is assigned to.
-
-Because we are leveraging the front matter system to 
-define indexes for content, the indexes assigned to 
-each content piece are located in the usual place 
-(.Params.`plural`)
-
-#### Example
-
-    <ul id="tags">
-      {{ range .Params.tags }}
-        <li><a href="tags/{{ . | urlize }}">{{ . }}</a> </li>
-      {{ end }}
-    </ul>
-
-## Creating Indexes of Indexes
-
-Hugo also supports creating pages that list your values for each 
-index along with the number of content items associated with the 
-index key.
-
-This may take the form of a tag cloud or simply a list.
-
-To have hugo create these indexes of indexes pages, simply create
-a template in indexes called indexes.html
-
-Hugo provides two different versions of the index. One alphabetically
-sorted, the other sorted by most popular. It's important to recognize
-that the data structure of the two is different.
-
-#### Example indexes.html file (alphabetical)
-
-    {{ template "chrome/header.html" . }}
-    {{ template "chrome/subheader.html" . }}
-
-    <section id="main">
-      <div>
-       <h1 id="title">{{ .Title }}</h1>
-       <ul>
-       {{ $data := .Data }}
-        {{ range $key, $value := .Data.Index }}
-        <li><a href="{{ $data.Plural }}/{{ $key | urlize }}"> {{ $key }} </a> {{ len $value }} </li>
-        {{ end }}
-       </ul>
-      </div>
-    </section>
-
-    {{ template "chrome/footer.html" }}
-
-
-#### Example indexes.html file (ordered)
-
-    {{ template "chrome/header.html" . }}
-    {{ template "chrome/subheader.html" . }}
-
-    <section id="main">
-      <div>
-       <h1 id="title">{{ .Title }}</h1>
-       <ul>
-        {{ range $data.OrderedIndex }}
-        <li><a href="{{ $data.Plural }}/{{ .Name | urlize }}"> {{ .Name }} </a> {{ .Count }} </li>
-        {{ end }}
-       </ul>
-      </div>
-    </section>
-
-    {{ template "chrome/footer.html" }}
-
-### Variables available to indexes of indexes pages.
-
-**.Title**  The title for the content. <br>
-**.Date** The date the content is published on.<br>
-**.Permalink** The Permanent link for this page.<br>
-**.RSSLink** Link to the indexes' rss link. <br>
-**.Data.Singular** The singular name of the index <br>
-**.Data.Plural** The plural name of the index<br>
-**.Data.Index** The Alphabetical index<br>
-**.Data.OrderedIndex** The popular index<br>
-

docs/content/doc/installing.md

@@ -1,46 +0,0 @@
----
-title: "Installing Hugo"
-Pubdate: "2013-07-01"
----
-
-Hugo is written in GoLang with support for Windows, Linux, FreeBSD and OSX.
-
-The latest release can be found at [hugo releases](https://github.com/spf13/hugo/releases).
-We currently build for Windows, Linux, FreeBSD and OS X for x64
-and 386 architectures. 
-
-## Installing Hugo (binary)
-
-Installation is very easy. Simply download the appropriate version for your
-platform from [hugo releases](https://github.com/spf13/hugo/releases).
-Once downloaded it 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.
-
-*the Hugo executible has no external dependencies.*
-
-## Installing from source
-
-### Dependencies
-
-* Git
-* Go 1.1+
-* Mercurial
-* Bazaar
-
-### Get directly from Github:
-
-    go get github.com/spf13/hugo
-
-### Building Hugo
-
-    cd /path/to/hugo
-    go build -o hugo main.go
-    mv hugo /usr/local/bin/
-
-## Contributing
-
-Please see the [contributing guide](/doc/contributing)

docs/content/doc/license.md

@@ -1,75 +0,0 @@
----
-title: "License"
-Pubdate: "2013-07-01"
----
-
-Hugo is released under the Simple Public License.
-
-
-Simple Public License (SimPL-2.0)
-=================================
-
-Preamble
---------
-
-This Simple Public License 2.0 (SimPL-2.0 for short) is a plain language
-implementation of GPL 2.0.  The words are different, but the goal is the
-same - to guarantee for all users the freedom to share and change
-software.  If anyone wonders about the meaning of the SimPL, they should
-interpret it as consistent with GPL 2.0.
-
-
-Simple Public License (SimPL) 2.0
-=================================
-
-The SimPL applies to the software's source and object code and comes
-with any rights that I have in it (other than trademarks). You agree to
-the SimPL by copying, distributing, or making a derivative work of the
-software.
-
- You get the royalty free right to:
-
--   Use the software for any purpose;
--   Make derivative works of it (this is called a "Derived Work");
--   Copy and distribute it and any Derived Work.
-
-If you distribute the software or a Derived Work, you must give back to
-the community by:
-
--   Prominently noting the date of any changes you make;
--   Leaving other people's copyright notices, warranty disclaimers, and
-    license terms in place;
--   Providing the source code, build scripts, installation scripts, and
-    interface definitions in a form that is easy to get and best to
-    modify;
--   Licensing it to everyone under SimPL, or substantially similar terms
-    (such as GPL 2.0), without adding further restrictions to the rights
-    provided;
--   Conspicuously announcing that it is available under that license.
-
-There are some things that you must shoulder:
-
--   You get NO WARRANTIES. None of any kind;
--   If the software damages you in any way, you may only recover direct
-    damages up to the amount you paid for it (that is zero if you did
-    not pay anything). You may not recover any other damages, including
-    those called "consequential damages." (The state or country where
-    you live may not allow you to limit your liability in this way, so
-    this may not apply to you);
-
-The SimPL continues perpetually, except that your license rights end
-automatically if:
-
--   You do not abide by the "give back to the community" terms (your
-    licensees get to keep their rights if they abide);
--   Anyone prevents you from distributing the software under the terms
-    of the SimPL.
-
-License for the License
------------------------
-
-You may do anything that you want with the SimPL text; it's a license
-form to use in any way that you find helpful.  To avoid confusion,
-however, if you change the terms in any way then you may not call your
-license the Simple Public License or the SimPL (but feel free to
-acknowledge that your license is "based on the Simple Public License").

docs/content/doc/organization.md

@@ -1,22 +0,0 @@
----
-title: "Organization"
-Pubdate: "2013-07-01"
----
-
-Hugo uses markdown files with headers commonly called the front matter. Hugo respects the organization
-that you provide for your content to minimize any extra configuration, though this can be overridden
-by additional configuration in the front matter.
-
-## Organization
-In Hugo the content should be arranged in the same way they are intended for the rendered website.
-Without any additional configuration the following will just work.
-
-    .
-    └── content
-        ├── post
-        |   ├── firstpost.md   // <- http://site.com/post/firstpost.html
-        |   └── secondpost.md  // <- http://site.com/post/secondpost.html
-        └── quote
-            ├── first.md       // <- http://site.com/quote/first.html
-            └── second.md      // <- http://site.com/quote/second.html
-

docs/content/doc/release-notes.md

@@ -1,26 +0,0 @@
----
-title: "Release Notes"
-Pubdate: "2013-07-01"
----
-
-* **0.8.0** August 2, 2013
-  * Added support for pretty urls (filename/index.html vs filename.html)
-  * Hugo supports a destination directory
-  * Will efficiently sync content in static to destination directory
-  * Cleaned up options.. now with support for short and long options
-  * Added support for TOML
-  * Added support for YAML
-  * Added support for Previous & Next
-  * Added support for indexes for the indexes
-  * Better Windows compatibility
-  * Support for series
-  * Adding verbose output
-  * Loads of bugfixes
-* **0.7.0** July 4, 2013
-  * Hugo now includes a simple server
-  * First public release
-* **0.6.0** July 2, 2013
-  * Hugo includes an example documentation site which it builds
-* **0.5.0** June 25, 2013
-  * Hugo is quite usable and able to build spf13.com
-

docs/content/doc/roadmap.md

@@ -1,17 +0,0 @@
----
-title: "Roadmap"
-Pubdate: "2013-07-01"
----
-
-In no particular order, here is what we are working on:
-
- * Pagination
- * Support for top level pages (other than homepage)
- * Better error handling
- * Syntax highlighting
- * Commands
- * Actions (eg. hugo create page)
- * Related Posts
- * Support for other formats
-
-

docs/content/doc/shortcodes.md

@@ -1,76 +0,0 @@
----
-title: "Shortcodes"
-Pubdate: "2013-07-01"
----
-
-Because Hugo uses markdown for it's content format, it was clear that there's a lot of things that 
-markdown doesn't support well. This is good, the simple nature of markdown is exactly why we chose it.
-
-However we cannot accept being constrained by our simple format. Also unacceptable is writing raw
-html in our markdown every time we want to include unsupported content such as a video. To do 
-so is in complete opposition to the intent of using a bare bones format for our content and 
-utilizing templates to apply styling for display.
-
-To avoid both of these limitations Hugo has full support for shortcodes.
-
-### What is a shortcode?
-A shortcode is a simple snippet inside a markdown file that Hugo will render using a template.
-
-Short codes are designated by the opening and closing characters of '{{%' and '%}}' respectively.
-Short codes are space delimited. The first word is always the name of the shortcode.  Following the 
-name are the parameters. The author of the shortcode can choose if the short code
-will use positional parameters or named parameters (but not both). A good rule of thumb is that if a
-short code has a single required value in the case of the youtube example below then positional
-works very well. For more complex layouts with optional parameters named parameters work best.
-
-The format for named parameters models that of html with the format name="value"
-
-### Example: youtube
-*Example has an extra space so Hugo doesn't actually render it*
-
-    {{ % youtube 09jf3ow9jfw %}}
-
-This would be rendered as 
-
-    <div class="embed video-player">
-    <iframe class="youtube-player" type="text/html"
-        width="640" height="385" 
-        src="http://www.youtube.com/embed/09jf3ow9jfw"
-        allowfullscreen frameborder="0">
-    </iframe>
-    </div>
-
-### Example: image with caption
-*Example has an extra space so Hugo doesn't actually render it*
-
-    {{ % img src="/media/spf13.jpg" title="Steve Francia" %}}
-
-Would be rendered as:
-
-    <figure >
-        <img src="/media/spf13.jpg"  />
-        <figcaption>
-            <h4>Steve Francia</h4>
-        </figcaption>
-    </figure>
-
-
-### Creating a shortcode
-
-All that you need to do to create a shortcode is place a template in the layouts/shortcodes directory.
-
-The template name will be the name of the shortcode.
-
-**Inside the template**
-
-To access a parameter by either position or name the index method can be used.
-
-    {{ index .Params 0 }}
-    or
-    {{ index .Params "class" }}
-
-To check if a parameter has been provided use the isset method provided by Hugo.
-
-    {{ if isset .Params "class"}} class="{{ index .Params "class"}}" {{ end }}
-
-

docs/content/doc/source-directory.md

@@ -1,54 +0,0 @@
----
-title: "Source Directory Organization"
-Pubdate: "2013-07-01"
----
-
-Hugo takes a single directory and uses it as the input for creating a complete website.
-
-Hugo has a very small amount of configuration, while remaining highly customizable. 
-It accomplishes by assuming that you will only provide templates with the intent of
-using them.
-
-An example directory may look like:
-
-    .
-    ├── config.yaml
-    ├── content
-    |   ├── post
-    |   |   ├── firstpost.md
-    |   |   └── secondpost.md
-    |   └── quote
-    |   |   ├── first.md
-    |   |   └── second.md
-    ├── layouts
-    |   ├── chrome
-    |   |   ├── header.html
-    |   |   └── footer.html
-    |   ├── indexes
-    |   |   ├── category.html
-    |   |   ├── post.html
-    |   |   ├── quote.html
-    |   |   └── tag.html
-    |   ├── post
-    |   |   ├── li.html
-    |   |   ├── single.html
-    |   |   └── summary.html
-    |   ├── quote
-    |   |   ├── li.html
-    |   |   ├── single.html
-    |   |   └── summary.html
-    |   ├── shortcodes
-    |   |   ├── img.html
-    |   |   ├── vimeo.html
-    |   |   └── youtube.html
-    |   ├── index.html
-    |   └── rss.xml
-    └── static
-
-This directory structure tells us a lot about this site:
-
-1. the website intends to have two different types of content, posts and quotes.
-2. It will also apply two different indexes to that content, categories and tags.
-3. It will be displaying content in 3 different views, a list, a summary and a full page view.
-
-Included with the repository is this example site ready to be rendered.

docs/content/doc/templates.md

@@ -1,66 +0,0 @@
----
-title: "Templates"
-Pubdate: "2013-07-01"
----
-
-Hugo uses the excellent golang html/template library for it's template engine. It is an extremely
-lightweight engine that provides a very small amount of logic. In our 
-experience that it is just the right amount of logic to be able to create a good static website
-
-This document will not cover how to use golang templates, but the [golang docs](http://golang.org/pkg/html/template/)
-provide a good introduction.
-
-### Template roles
-
-There are 5 different kinds of templates that Hugo works with.
-
-#### index.html
-This file must exist in the layouts directory. It is the template used to render the 
-homepage of your site.
-
-#### rss.xml
-This file must exist in the layouts directory. It will be used to render all rss documents.
-The one provided in the example application will generate an ATOM format. 
-
-*Important: Hugo will automatically add the following header line to this file.*
-
-    <?xml version="1.0" encoding="utf-8" standalone="yes" ?>
-
-#### Indexes
-An index is a page that list multiple pieces of content. If you think of a typical blog, the tag 
-pages are good examples of indexes.
-
-
-#### Content Type(s)
-Hugo supports multiple types of content. Another way of looking at this is that Hugo has the ability
-to render content in a variety of ways as determined by the type.
-
-#### Chrome
-Chrome is simply the decoration of your site. It's not a requirement to have this, but in practice
-it's very convenient. Hugo doesn't know anything about Chrome, it's simply a convention that you may
-likely find beneficial. As you create the rest of your templates you will include templates from the 
-/layout/chrome directory. I've found it helpful to include a header and footer template 
-in Chrome so I can include those in the other full page layouts (index.html, indexes/ type/single.html).
-
-### Adding a new content type
-
-Adding a type is easy.
-
-**Step 1:**
-Create a directory with the name of the type in layouts.Type is always singular.  *Eg /layouts/post*.
-
-**Step 2:**
-Create a file called single.html inside your directory. *Eg /layouts/post/single.html*.
-
-**Step 3:**
-Create a file with the same name as your directory in /layouts/indexes/. *Eg /layouts/index/post.html*.
-
-**Step 4:**
-Many sites support rendering content in a few different ways, for instance a single page view and a 
-summary view to be used when displaying a list of contents on a single page. Hugo makes no assumptions
-here about how you want to display your content, and will support as many different views of a content
-type as your site requires. All that is required for these additional views is that a template
-exists in each layout/type directory with the same name.
-
-For these, reviewing this example site will be very helpful in order to understand how these types work.
-

docs/content/doc/usage.md

@@ -1,55 +0,0 @@
----
-title: "Using Hugo"
-Pubdate: "2013-07-01"
----
-
-Make sure either hugo is in your path or provide a path to it.
-
-    $ hugo --help
-    usage: hugo [flags] []
-      -b, --base-url="": hostname (and path) to the root eg. http://spf13.com/
-      -D, --build-drafts=false: include content marked as draft
-          --config="": config file (default is path/config.yaml|json|toml)
-      -d, --destination="": filesystem path to write files to
-      -h, --help=false: show this help
-          --port="1313": port to run web server on, default :1313
-      -S, --server=false: run a (very) simple web server
-      -s, --source="": filesystem path to read files relative from
-          --uglyurls=false: use /filename.html instead of /filename/
-      -v, --verbose=false: verbose output
-          --version=false: which version of hugo
-      -w, --watch=false: watch filesystem for changes and recreate as needed
-
-## Common Usage Example:
-
-The most common use is probably to run hugo with your current
-directory being the input directory.
-
-
-    $ hugo
-    > X pages created
-    > Y indexes created
-      in 8 ms
-
-
-If you are working on things and want to see the changes
-immediately, tell Hugo to watch for changes. **It will
-recreate the site faster than you can tab over to
-your browser to view the changes.**
-
-    $ hugo --source ~/mysite --watch
-       Watching for changes. Press ctrl+c to stop
-       15 pages created
-       0 tags created
-       in 8 ms
-
-Hugo can even run a server and create your site at the same time!
-
-    $hugo --server -ws ~/mysite
-       Watching for changes. Press ctrl+c to stop
-       15 pages created
-       0 tags created
-       in 8 ms
-       Web Server is available at http://localhost:1313
-       Press ctrl+c to stop
-

docs/content/doc/variables.md

@@ -1,31 +0,0 @@
----
-title: "Variables"
-Pubdate: "2013-07-01"
----
-
-Hugo makes a set of values available to the templates. Go templates are context based. The following
-are available in the context for the templates.
-
-**.Title**  The title for the content. <br>
-**.Description** The description for the content.<br>
-**.Keywords** The meta keywords for this content.<br>
-**.Date** The date the content is published on.<br>
-**.Indexes** These will use the field name of the plural form of the index (see tags and categories above)<br>
-**.Permalink** The Permanent link for this page.<br>
-**.FuzzyWordCount** The approximate number of words in the content.<br>
-**.RSSLink** Link to the indexes' rss link <br>
-**.Prev** Pointer to the previous content (based on pub date)<br>
-**.Next** Pointer to the following content (based on pub date)<br>
-
-Any value defined in the front matter, including indexes will be made available under `.Params`. 
-Take for example I'm using tags and categories as my indexes. The following would be how I would access them:
-
-**.Params.Tags** <br> 
-**.Params.Categories** <br> 
-
-Also available is `.Site` which has the following:
-
-**.Site.BaseUrl** The base URL for the site as defined in the config.json file.<br>
-**.Site.Indexes** The names of the indexes of the site.<br>
-**.Site.LastChange** The date of the last change of the most recent content.<br>
-**.Site.Recent** Array of all content ordered by Date, newest first<br>

docs/layouts/chrome/footer.html

@@ -1,12 +0,0 @@
-        </div>
-      </div>
-      <hr>
-      <footer id="footer">
-            <p class="pull-right"><a href="#top">Back to top</a></p>
-            Made by <a href="http://spf13.com">Steve Francia</a>.<br>
-            Code licensed under the <a href="https://github.com/spf13/hugo/blob/master/LICENSE.md">Simple Public License 2.0</a>.<br>
-      </footer>
-    </div>
-  </body>
-
-</html>

docs/layouts/chrome/header.html

@@ -1,20 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-  <title>{{ .Title }}</title>
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <meta content="text/html; charset=UTF-8" http-equiv="Content-Type">
-    {{ template "chrome/includes.html" . }}
-  </head>
-  <body>
-    <div class="navbar"></div>
-    <div class="container-fluid">
-      <div class="row-fluid">
-        <div class="span3">
-          <div class="well" style="background-color: #222; color: #ccc;">
-            <h1>Hugo</h1>
-            <p>A Fast and Flexible Static Site Generator built with love by <a href="http://spf13.com">spf13</a> in Go</p>
-          </div>
-        {{ template "chrome/menu.html" . }}
-        </div>
-        <div class="span9">

docs/layouts/chrome/includes.html

@@ -1,2 +0,0 @@
-    <link rel="stylesheet" href="/static/css/bootstrap.min.css">
-    <link rel="stylesheet" href="/static/css/bootstrap-responsive.css">

docs/layouts/chrome/menu.html

@@ -1,29 +0,0 @@
-          <ul class="nav nav-list">
-            <li> <a href="/">Home</a></li>
-            <li class="divider"></li>
-            <li class="nav-header">Getting Started</li>
-            <li> <a href="/doc/installing">Installing Hugo</a></li>
-            <li> <a href="/doc/usage">Usage</a> </li>
-            <li> <a href="/doc/configuration">Configuration</a></li>
-            <li> <a href="/doc/source-directory">Input Directory Layout</a></li>
-            <li class="divider"></li>
-            <li class="nav-header">Layout</li>
-            <li> <a href="/doc/templates">Templates</a></li>
-            <li> <a href="/doc/variables">Variables</a></li>
-            <li class="divider"></li>
-            <li class="nav-header">Content</li>
-            <li> <a href="/doc/organization">Organization</a></li>
-            <li> <a href="/doc/front-matter">Front Matter</a></li>
-            <li> <a href="/doc/example">Example</a></li>
-            <li class="divider"></li>
-            <li class="nav-header">Extras</li>
-            <li> <a href="/doc/shortcodes">ShortCodes</a></li>
-            <li> <a href="/doc/indexes">Indexes</a></li>
-            <li class="divider"></li>
-            <li class="nav-header">Meta</li>
-            <li> <a href="/doc/release-notes">Release Notes</a></li>
-            <li> <a href="/doc/roadmap">Roadmap</a> </li>
-            <li> <a href="/doc/contributing">Contributing</a></li>
-            <li> <a href="/doc/contributors">Contributors</a></li>
-            <li> <a href="/doc/license">License</a></li>
-          </ul>

docs/layouts/doc/single.html

@@ -1,4 +0,0 @@
-{{ template "chrome/header.html" . }}
-          <h1>{{ .Title }}</h1>
-          {{ .Content }}
-{{ template "chrome/footer.html" . }}

docs/layouts/index.html

@@ -1,54 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <title>Hugo Static Site Generator written in Go lang</title>
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <meta content="text/html; charset=UTF-8" http-equiv="Content-Type">
-    {{ template "chrome/includes.html" . }}
-  </head>
-  <body>
-    <div class="navbar"></div>
-    <div class="container-fluid">
-      <div class="row-fluid">
-        <div class="span3">
-        {{ template "chrome/menu.html" . }}
-        </div>
-        <div class="span9">
-
-          <div class="hero-unit" style="background-color: #222; color: #ccc;">
-            <h1>Hugo</h1>
-            <p>A Fast and Flexible Static Site Generator built with love by <a href="http://spf13.com">spf13</a> 
-            and <a href="http://github.com/spf13/hugo/graphs/contributors">friends</a> in Go</p>
-            <p>
-              <a class="btn btn-large btn-success" href="/doc/installing.html">Get Started</a> 
-            </p>
-          </div>
-          <div class="row-fluid">
-            <div class="span4">
-              <h2>Fast
-                <br> 
-              </h2>
-              <p>Written in GoLang for speed, Hugo is significantly faster than most
-              other static site generators.
-              A typical website of moderate size can be
-              rendered in a fraction of a second. A good rule of thumb is that Hugo
-              takes around 1 millisecond for each piece of content.<br>
-              It's so fast that it will render the site in 
-              less time than it takes to switch to your browser and reload.</p>
-            </div>
-            <div class="span4">
-              <h2>Flexible</h2>
-              <p>Hugo is made to be very flexible. Define your own content types. Define
-              your own indexes. Build your own templates, shortcodes and more.
-              It is written to work well with any
-              kind of website including blogs, tumbles and docs.</p>
-            </div>
-            <div class="span4">
-              <h2>Fun</h2>
-              <p>Hugo runs everywhere. Sites generated with Hugo work on every web 
-              server without any special configuration. Hugo
-              removes all the cruft of building a site allowing you to 
-              focus on writing great content.</p>
-            </div>
-          </div>
-{{ template "chrome/footer.html" }}

docshelper/docs.go

@@ -0,0 +1,32 @@
+// Copyright 2017-present The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package docshelper provides some helpers for the Hugo documentation, and
+// is of limited interest for the general Hugo user.
+package docshelper
+
+import (
+	"encoding/json"
+)
+
+var DocProviders = make(map[string]DocProvider)
+
+func AddDocProvider(name string, provider DocProvider) {
+	DocProviders[name] = provider
+}
+
+type DocProvider func() map[string]interface{}
+
+func (d DocProvider) MarshalJSON() ([]byte, error) {
+	return json.MarshalIndent(d(), "", "  ")
+}

examples/blog/.gitignore

@@ -0,0 +1,12 @@
+# Hugo default output directory
+/public
+
+## OS Files
+# Windows
+Thumbs.db
+ehthumbs.db
+Desktop.ini
+$RECYCLE.BIN/
+
+# OSX
+.DS_Store

examples/blog/README.md

@@ -0,0 +1,42 @@
+Hugo Example Blog
+=================
+
+This repository provides a fully-working example of a [Hugo](https://github.com/gohugoio/hugo)-powered blog. Many
+Hugo-specific features are used as a way to see them in action, and hopefully ease the learning curve for creating your
+very own site with Hugo.
+
+Features
+--------
+
+- Recent Posts at main index
+- Indexes for `tags` and `categories`
+- Post information block, with links for all `tags` and `categories` post belongs to
+- [Bootstrap 3](http://getbootstrap.com/) ready
+  - Currently using the [Yeti](http://bootswatch.com/yeti/) theme from http://bootswatch.com/
+
+Common things that should be added in the near future *(pull requests are welcome!)*:
+
+- Disqus integration
+- More content types to demonstrate different layout methods
+  - About Me
+  - Contact
+
+Getting Started
+---------------
+
+To get started, you should simply fork or clone this repository! That's definitely an important first step.
+
+[Install Hugo](http://gohugo.io/overview/installing) in a way that best suits your environment and comfort level.
+
+Edit `config.toml` and change the default properties to suit your own information. This is not required to run the
+example, but this is the global configuration file and you're going to need to use it eventually. Start here!
+
+In a command prompt or terminal, navigate to the path that contains your `config.toml` file and run `hugo`. That's it!
+You should now have a `public` directory with a complete blog! Open `public/index.html` in your browser and bask.
+
+If that wasn't amazing enough, from the same terminal, run `hugo server`. This will watch your directories for changes
+and rebuild the site immediately, *and* it will make these changes available at http://localhost:1313/ so you can view
+your finished site in your browser. Go on, try it. This is one of the best ways to preview your site while working on it.
+
+To further learn Hugo and learn more, read through the Hugo [documentation](http://gohugo.io/overview/introduction)
+or browse around the files in this repository. Have fun!

examples/blog/config.toml

@@ -0,0 +1,4 @@
+baseURL = "http://blog.hugoexample.com/"
+languageCode = "en-us"
+title = "Hugo Example Blog"
+canonifyURLs = true

examples/blog/content/post/another-post.md

@@ -0,0 +1,57 @@
++++
+title = "Another Hugo Post"
+description = "Nothing special, but one post is boring."
+date = "2014-09-02"
+categories = [ "example", "configuration" ]
+tags = [
+    "example",
+    "hugo",
+    "toml"
+]
++++
+
+TOML, YAML, JSON --- Oh my!
+-------------------------
+
+One of the nifty Hugo features we should cover: flexible configuration and front matter formats! This entry has front
+matter in `toml`, unlike the last one which used `yaml`, and `json` is also available if that's your preference.
+
+<!--more-->
+
+The `toml` front matter used on this entry:
+
+```
++++
+title = "Another Hugo Post"
+description = "Nothing special, but one post is boring."
+date = "2014-09-02"
+categories = [ "example", "configuration" ]
+tags = [
+    "example",
+    "hugo",
+    "toml"
+]
++++
+```
+
+This flexibility also extends to your site's global configuration file. You're free to use any format you prefer::simply
+name the file `config.yaml`, `config.toml` or `config.json`, and go on your merry way.
+
+JSON Example
+------------
+
+How would this entry's front matter look in `json`? That's easy enough to demonstrate:
+
+```
+{
+    "title": "Another Hugo Post",
+    "description": "Nothing special, but one post is boring.",
+    "date": "2014-09-02",
+    "categories": [ "example", "configuration" ],
+    "tags": [
+        "example",
+        "hugo",
+        "toml"
+    ],
+}
+```

examples/blog/content/post/hello-hugo.md

@@ -0,0 +1,61 @@
+---
+title: "Hello Hugo!"
+description: "Saying 'Hello' from Hugo"
+date: "2014-09-01"
+categories:
+  - "example"
+  - "hello"
+tags:
+  - "example"
+  - "hugo"
+  - "blog"
+---
+
+Hello from Hugo! If you're reading this in your browser, good job! The file `content/post/hello-hugo.md` has been
+converted into a complete HTML document by Hugo. Isn't that pretty nifty?
+
+A Section
+---------
+
+Here's a simple titled section where you can place whatever information you want.
+
+You can use inline HTML if you want, but really there's not much that Markdown can't do.
+
+Showing off with Markdown
+-------------------------
+
+A full cheat sheet can be found [here](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet)
+or through [Google](https://google.com/).
+
+There are some *easy* examples for styling, though. I can't **emphasize** that enough.
+Creating [links](https://google.com/) or `inline code` blocks are very straightforward.
+
+```
+There are some *easy* examples for styling, though. I can't **emphasize** that enough.
+Creating [links](https://google.com/) or `inline code` blocks are very straightforward.
+```
+
+Front Matter for Fun
+--------------------
+
+This is the meta data for this post. It is located at the top of the `content/post/hello-hugo.md` markdown file.
+
+```
+---
+title: "Hello Hugo!"
+description: "Saying 'Hello' from Hugo"
+date: "2014-09-01"
+categories:
+  - "example"
+  - "hello"
+tags:
+  - "example"
+  - "hugo"
+  - "blog"
+---
+```
+
+This section, called 'Front Matter', is what tells Hugo about the content in this file: the `title` of the item, the
+`description`, and the `date` it was posted. In our example, we've added two custom bits of data too. The `categories` and
+`tags` sections are used in this example for indexing/grouping content. You will learn more about what that means by
+examining the code in this example and through reading the Hugo [documentation](http://gohugo.io/overview/introduction).

examples/blog/layouts/_default/single.html

@@ -0,0 +1,21 @@
+{{ partial "header.html" . }}
+<body>
+{{ partial "navbar.html" . }}
+<div class="container">
+    <div class="row">
+        <div class="col-md-9">
+            <div class="well well-sm">
+                    <h3>{{ .Title }}<br> <small>{{ .Description }}</small></h3>
+                    <hr>
+                    {{ .Content }}
+            </div>
+        </div>
+
+        <!-- Sidebar -->
+        <div class="col-md-3">
+            {{ partial "menu.html" . }}
+        </div>
+    </div>
+{{ partial "footer.copyright.html" . }}
+</div>
+{{ partial "footer.html" . }}

examples/blog/layouts/index.html

@@ -0,0 +1,19 @@
+{{ partial "header.html" . }}
+<body>
+{{ partial "navbar.html" . }}
+<div class="container">
+    <div class="row">
+        <div class="col-md-9">
+        {{ range first 10 .Data.Pages }}
+            {{ .Render "summary" }}
+        {{ end }}
+        </div>
+
+        <!-- Sidebar -->
+        <div class="col-md-3">
+        {{ partial "menu.html" . }}
+        </div>
+    </div>
+{{ partial "footer.copyright.html" . }}
+</div>
+{{ partial "footer.html" . }}

examples/blog/layouts/indexes/category.html

@@ -0,0 +1,24 @@
+{{ partial "header.html" . }}
+<body>
+{{ partial "navbar.html" . }}
+<div class="container">
+    <div class="row">
+        <div class="col-md-9">
+            <div class="well well-sm">
+                <strong>Items in category <code>{{ .Title | lower }}</code></strong>
+                <ul class="list-unstyled">
+                    {{ range .Data.Pages }}
+                        {{ .Render "li" }}
+                    {{ end}}
+                </ul>
+            </div>
+        </div>
+
+        <!-- Sidebar -->
+        <div class="col-md-3">
+        {{ partial "menu.html" . }}
+        </div>
+    </div>
+{{ partial "footer.copyright.html" . }}
+</div>
+{{ partial "footer.html" . }}

examples/blog/layouts/indexes/post.html

@@ -0,0 +1,24 @@
+{{ partial "header.html" . }}
+<body>
+{{ partial "navbar.html" . }}
+<div class="container">
+    <div class="row">
+        <div class="col-md-9">
+            <div class="well well-sm">
+                <strong>Blog Post Archive</strong>
+                <ul class="list-unstyled">
+                    {{ range .Data.Pages }}
+                        {{ .Render "li" }}
+                    {{ end}}
+                </ul>
+            </div>
+        </div>
+
+        <!-- Sidebar -->
+        <div class="col-md-3">
+        {{ partial "menu.html" . }}
+        </div>
+    </div>
+{{ partial "footer.copyright.html" . }}
+</div>
+{{ partial "footer.html" . }}

examples/blog/layouts/indexes/tag.html

@@ -0,0 +1,24 @@
+{{ partial "header.html" . }}
+<body>
+{{ partial "navbar.html" . }}
+<div class="container">
+    <div class="row">
+        <div class="col-md-9">
+            <div class="well well-sm">
+                <strong>Items with tag <code>{{ .Title | lower }}</code></strong>
+                <ul class="list-unstyled">
+                    {{ range .Data.Pages }}
+                        {{ .Render "li" }}
+                    {{ end}}
+                </ul>
+            </div>
+        </div>
+
+        <!-- Sidebar -->
+        <div class="col-md-3">
+        {{ partial "menu.html" . }}
+        </div>
+    </div>
+{{ partial "footer.copyright.html" . }}
+</div>
+{{ partial "footer.html" . }}

examples/blog/layouts/partials/footer.copyright.html

@@ -0,0 +1,9 @@
+        <footer>
+            <div class="row">
+                <hr>
+                <div class="col-sm-12">
+                    <p>&copy; Enthusiastic Hugo User {{ .Now.Format "2006" }} &middot;
+                    Built with <a href="https://github.com/gohugoio/hugo">Hugo</a></p>
+                </div>
+            </div>
+        </footer>

examples/blog/layouts/partials/footer.html

@@ -0,0 +1,5 @@
+
+    <script src="/js/jquery-1.11.3.min.js"></script>
+    <script src="/js/bootstrap.js"></script>
+</body>
+</html>

examples/blog/layouts/partials/header.html

@@ -0,0 +1,10 @@
+<!doctype html>
+<html lang="en">
+<head>
+    {{ partial "meta.html" . }}
+
+    <title>{{ .Title }} - {{ .Site.BaseURL }}</title>
+    <link rel="canonical" href="{{ .Permalink }}">
+    {{ partial "header.includes.html" . }}
+    {{ if .RSSLink }}<link href="{{ .RSSLink }}" rel="alternate" type="application/rss+xml" title="{{ .Site.Title }}" />{{ end }}
+</head>

examples/blog/layouts/partials/header.includes.html

@@ -0,0 +1,4 @@
+
+    <link href="/css/bootstrap.min.css" rel="stylesheet">
+    <link href="/css/font-awesome.css" rel="stylesheet">
+    <link href="/css/custom.css" rel="stylesheet">

examples/blog/layouts/partials/menu.html

@@ -0,0 +1,15 @@
+    <div class="panel panel-default">
+        <div class="panel-heading" style="padding: 2px 15px;">
+            <h4>Connect. Socialize.</h4>
+        </div>
+        <div class="panel-body">
+            <a href="https://github.com/SomeSillyUserNameHere/" class="btn btn-primary btn-xs"><i class="fa fa-github-square fa-2x"></i></a>
+            <a href="https://www.facebook.com/SomeSillyUserNameHere" class="btn btn-info btn-xs"><i class="fa fa-facebook-square fa-2x"></i></a>
+
+            <div class="alert alert-info alert-dismissable" style="margin-top:25px;margin-bottom:5px;">
+                <button type="button" class="close" data-dismiss="alert" aria-hidden="true">&times;</button>
+                <strong>Hey, listen!</strong><br>
+                You should modify the <code>layouts/partials/menu.html</code> template and include your own profile links.
+            </div>
+        </div>
+    </div>

examples/blog/layouts/partials/meta.html

@@ -0,0 +1,6 @@
+
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta name="description" content="{{ .Description }}">
+    <meta name="author" content="A Hugo User"> <!-- This should be modified to be your name, if you want to include this information -->

examples/blog/layouts/partials/navbar.html

@@ -0,0 +1,22 @@
+    <nav class="navbar navbar-default navbar-fixed-top" role="navigation">
+        <div class="container">
+            <div class="navbar-header">
+                <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-ex1-collapse">
+                    <span class="sr-only">Toggle Navigation</span>
+                    <span class="icon-bar"></span>
+                    <span class="icon-bar"></span>
+                    <span class="icon-bar"></span>
+                </button>
+                <a class="navbar-brand" href="{{ .Site.BaseURL }}">{{ .Site.Title }}</a>
+            </div>
+            <div class="collapse navbar-collapse navbar-ex1-collapse">
+                <ul class="nav navbar-nav">
+                    <li><a href="/post/">Post Index</a></li>
+                    <!--
+                    And here is where you'd add more links to sections, or anywhere you like.
+                    <li><a href="#">About Me</a></li>
+                    -->
+                </ul>
+            </div>
+        </div>
+    </nav>

examples/blog/layouts/post/li.html

@@ -0,0 +1,4 @@
+    <li>
+        <h5><a href="{{ .Permalink }}">{{ .Title}}</a><br>
+        <small>posted on {{ .Date.Format "January 2, 2006" }}</small></h5>
+    </li>

examples/blog/layouts/post/single.html

@@ -0,0 +1,35 @@
+{{ partial "header.html" . }}
+<body>
+{{ partial "navbar.html" . }}
+<div class="container">
+    <div class="row">
+        <div class="col-md-9">
+            <div class="well well-sm">
+                    <h3>{{ .Title }}<br> <small>{{ .Description }}</small></h3>
+                    <hr>
+                    {{ .Content }}
+            </div>
+        </div>
+
+        <!-- Sidebar -->
+        <div class="col-md-3">
+            <div class="well well-sm"> <!-- Post-specific stats -->
+                <h4>{{ .Date.Format "January 2, 2006" }}<br>
+                <small>{{ .WordCount }} words</small></h4>
+                <hr>
+                <strong>Categories</strong>
+                <ul class="list-unstyled">
+                {{ range .Params.categories }}
+                    <li><a href="/categories/{{ . | urlize }}">{{ . }}</a></li>
+                {{ end }}
+                </ul>
+                <hr>
+                <strong>Tags</strong><br>
+                {{ range .Params.tags }}<a class="label label-default" href="/tags/{{ . | urlize }}">{{ . }}</a> {{ end }}
+            </div>
+            {{ partial "menu.html" . }}
+        </div>
+    </div>
+{{ partial "footer.copyright.html" . }}
+</div>
+{{ partial "footer.html" . }}

examples/blog/layouts/post/summary.html

@@ -0,0 +1,9 @@
+<div class="well well-sm">
+    <h4>
+        <a href="{{ .Permalink }}">{{ .Title }}</a> <small class="pull-right">Posted on {{ .Date.Format "Jan 2, 2006" }}</small><br>
+        <small>{{ .Description }}</small>
+    </h4>
+    <hr>
+    <p>{{ .Summary }}</p>
+    <a class="btn btn-primary btn-xs" href="{{ .Permalink }}">Read More <span class="fa fa-angle-double-right"></span></a>
+</div>

examples/blog/static/css/custom.css

@@ -0,0 +1,7 @@
+body {
+    margin-top: 75px; /* 100px is double the height of the navbar - I made it a big larger for some more space - keep it at 50px at least if you want to use the fixed top nav */
+}
+
+footer {
+    margin: 50px 0;
+}