improvements

LICENSE

@@ -0,0 +1,373 @@
+Mozilla Public License Version 2.0
+==================================
+
+1. Definitions
+--------------
+
+1.1. "Contributor"
+    means each individual or legal entity that creates, contributes to
+    the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+    means the combination of the Contributions of others (if any) used
+    by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+    means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+    means Source Code Form to which the initial Contributor has attached
+    the notice in Exhibit A, the Executable Form of such Source Code
+    Form, and Modifications of such Source Code Form, in each case
+    including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+    means
+
+    (a) that the initial Contributor has attached the notice described
+        in Exhibit B to the Covered Software; or
+
+    (b) that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the
+        terms of a Secondary License.
+
+1.6. "Executable Form"
+    means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+    means a work that combines Covered Software with other material, in
+    a separate file or files, that is not Covered Software.
+
+1.8. "License"
+    means this document.
+
+1.9. "Licensable"
+    means having the right to grant, to the maximum extent possible,
+    whether at the time of the initial grant or subsequently, any and
+    all of the rights conveyed by this License.
+
+1.10. "Modifications"
+    means any of the following:
+
+    (a) any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered
+        Software; or
+
+    (b) any new file in Source Code Form that contains any Covered
+        Software.
+
+1.11. "Patent Claims" of a Contributor
+    means any patent claim(s), including without limitation, method,
+    process, and apparatus claims, in any patent Licensable by such
+    Contributor that would be infringed, but for the grant of the
+    License, by the making, using, selling, offering for sale, having
+    made, import, or transfer of either its Contributions or its
+    Contributor Version.
+
+1.12. "Secondary License"
+    means either the GNU General Public License, Version 2.0, the GNU
+    Lesser General Public License, Version 2.1, the GNU Affero General
+    Public License, Version 3.0, or any later versions of those
+    licenses.
+
+1.13. "Source Code Form"
+    means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+    means an individual or a legal entity exercising rights under this
+    License. For legal entities, "You" includes any entity that
+    controls, is controlled by, or is under common control with You. For
+    purposes of this definition, "control" means (a) the power, direct
+    or indirect, to cause the direction or management of such entity,
+    whether by contract or otherwise, or (b) ownership of more than
+    fifty percent (50%) of the outstanding shares or beneficial
+    ownership of such entity.
+
+2. License Grants and Conditions
+--------------------------------
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+    Licensable by such Contributor to use, reproduce, make available,
+    modify, display, perform, distribute, and otherwise exploit its
+    Contributions, either on an unmodified basis, with Modifications, or
+    as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+    for sale, have made, import, and otherwise transfer either its
+    Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+    or
+
+(b) for infringements caused by: (i) Your and any other third party's
+    modifications of Covered Software, or (ii) the combination of its
+    Contributions with other software (except as part of its Contributor
+    Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+    its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+-------------------
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+    Form, as described in Section 3.1, and You must inform recipients of
+    the Executable Form how they can obtain a copy of such Source Code
+    Form by reasonable means in a timely manner, at a charge no more
+    than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+    License, or sublicense it under different terms, provided that the
+    license for the Executable Form does not attempt to limit or alter
+    the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+---------------------------------------------------
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+--------------
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+************************************************************************
+*                                                                      *
+*  6. Disclaimer of Warranty                                           *
+*  -------------------------                                           *
+*                                                                      *
+*  Covered Software is provided under this License on an "as is"       *
+*  basis, without warranty of any kind, either expressed, implied, or  *
+*  statutory, including, without limitation, warranties that the       *
+*  Covered Software is free of defects, merchantable, fit for a        *
+*  particular purpose or non-infringing. The entire risk as to the     *
+*  quality and performance of the Covered Software is with You.        *
+*  Should any Covered Software prove defective in any respect, You     *
+*  (not any Contributor) assume the cost of any necessary servicing,   *
+*  repair, or correction. This disclaimer of warranty constitutes an   *
+*  essential part of this License. No use of any Covered Software is   *
+*  authorized under this License except under this disclaimer.         *
+*                                                                      *
+************************************************************************
+
+************************************************************************
+*                                                                      *
+*  7. Limitation of Liability                                          *
+*  --------------------------                                          *
+*                                                                      *
+*  Under no circumstances and under no legal theory, whether tort      *
+*  (including negligence), contract, or otherwise, shall any           *
+*  Contributor, or anyone who distributes Covered Software as          *
+*  permitted above, be liable to You for any direct, indirect,         *
+*  special, incidental, or consequential damages of any character      *
+*  including, without limitation, damages for lost profits, loss of    *
+*  goodwill, work stoppage, computer failure or malfunction, or any    *
+*  and all other commercial damages or losses, even if such party      *
+*  shall have been informed of the possibility of such damages. This   *
+*  limitation of liability shall not apply to liability for death or   *
+*  personal injury resulting from such party's negligence to the       *
+*  extent applicable law prohibits such limitation. Some               *
+*  jurisdictions do not allow the exclusion or limitation of           *
+*  incidental or consequential damages, so this exclusion and          *
+*  limitation may not apply to You.                                    *
+*                                                                      *
+************************************************************************
+
+8. Litigation
+-------------
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+----------------
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+---------------------------
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+-------------------------------------------
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+---------------------------------------------------------
+
+  This Source Code Form is "Incompatible With Secondary Licenses", as
+  defined by the Mozilla Public License, v. 2.0.

assets/assets.go

@@ -1,2 +1,2 @@
-//go:generate go-bindata -pkg assets simplemde/dist/... simplemde/debug/...
+//go:generate go-bindata -pkg assets simplemde/dist/... simplemde/debug/... js/... css/...
 package assets

caddyhugo.go

@@ -1,528 +1,141 @@
 package caddyhugo
 
 import (
-	"encoding/base64"
-	"errors"
 	"fmt"
 	"html/template"
-	"io/ioutil"
 	"net/http"
-	_ "net/http/pprof"
-	"os"
-	"os/exec"
 	"path"
 	"path/filepath"
 	"strings"
 	"sync"
-	"time"
 
 	"git.stephensearles.com/stephen/acedoc"
-	"git.stephensearles.com/stephen/caddy-hugo2/assets"
+	"git.stephensearles.com/stephen/caddy-hugo2/comments"
+	"git.stephensearles.com/stephen/caddy-hugo2/media"
+	"go.uber.org/zap"
 
-	"github.com/gorilla/websocket"
-	"github.com/mholt/caddy"
-	"github.com/mholt/caddy/caddyhttp/httpserver"
+	"github.com/caddyserver/caddy/v2"
+	"github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
+	"github.com/caddyserver/caddy/v2/caddyconfig/httpcaddyfile"
+	"github.com/caddyserver/caddy/v2/modules/caddyhttp"
+	"github.com/gohugoio/hugo/deps"
+	"github.com/gohugoio/hugo/hugolib"
 	"github.com/spf13/afero"
-	"github.com/spf13/hugo/deps"
-	"github.com/spf13/hugo/hugofs"
-	"github.com/spf13/hugo/hugolib"
-)
-
-const (
-	IdleWebsocketTimeout = 10 * time.Minute
-	WebsocketFileTicker  = 1 * time.Second
 )
 
 func init() {
-	plugin := CaddyHugo{}
+	caddy.RegisterModule(&CaddyHugo{})
+	httpcaddyfile.RegisterHandlerDirective("hugo", parseCaddyfile)
+}
 
-	// register a "generic" plugin, like a directive or middleware
-	caddy.RegisterPlugin("hugo", caddy.Plugin{
-		ServerType: "http",
-		Action:     plugin.Setup,
+type SiteConfig struct {
+	Hosts            []string
+	Root             string
+	CommentsEnabled  bool
+	CommentsPassword string
+}
+
+func (m *CaddyHugo) CaddyModule() caddy.ModuleInfo {
+	return caddy.ModuleInfo{
+		ID:  "http.handlers.hugo",
+		New: func() caddy.Module { return new(CaddyHugo) },
+	}
+}
+
+func (m *CaddyHugo) Provision(ctx caddy.Context) error {
+	m.logger = ctx.Logger(m)
+
+	if m.Site.CommentsEnabled {
+		m.Comments = comments.WithStorage(comments.NewDiskv(path.Join(m.Site.Root, "comments")))
+	}
+
+	// TODO: not sure where m.Site is getting populated.
+	// m.Site.Root looks to be the working directory of caddy but it needs to be the directory of the site
+	root, err := filepath.Abs(m.Site.Root)
+	if err != nil {
+		return err
+	}
+
+	err = m.Setup(root)
+	if err != nil {
+		return err
+	}
+
+	ctx.OnCancel(func() {
+		m.persistAllEdits()
 	})
 
-	// ... there are others. See the godoc.
+	m.commentsSetting()
+	return nil
 }
 
-type docref struct {
-	clients uint
-	name    string
-	doc     *acedoc.Document
-	tmpdir  string
+// UnmarshalCaddyfile implements caddyfile.Unmarshaler.
+func (s *SiteConfig) UnmarshalCaddyfile(d *caddyfile.Dispenser) error {
+	for d.NextBlock(0) {
+		if d.Val() == "comments" {
+			if d.NextArg() {
+				s.CommentsPassword = d.Val()
+			}
+		}
+	}
+	return nil
 }
 
+// CaddyHugo implements the plugin for a single site
 type CaddyHugo struct {
+	logger *zap.Logger
+
 	ServerType string
-	Site       *httpserver.SiteConfig
+	Site       SiteConfig
 	HugoSites  *hugolib.HugoSites
 	HugoCfg    *deps.DepsCfg
 
-	Media *MediaSource
+	Dir string
 
-	docs map[string]*docref
+	Media    *media.MediaSource
+	Comments *comments.Service
+
+	docs map[string]*editSession
 	mtx  sync.Mutex
 
 	authorTmpl, adminTmpl, editTmpl *template.Template
 
 	ltime              uint64
+	confirmingToClient map[uint64]struct{}
 }
 
-func (ch *CaddyHugo) ObserveLTime(ltime uint64) uint64 {
-	ch.mtx.Lock()
-
-	if ch.ltime < ltime {
-		ch.ltime = ltime
-	}
-
-	ch.mtx.Unlock()
-	return ch.LTime()
+func (ch *CaddyHugo) log(msg string, args ...interface{}) {
+	all := make([]any, len(args)+1)
+	all[0] = msg
+	copy(all[1:], args)
+	ch.logger.Info(fmt.Sprint(all...))
 }
 
-func (ch *CaddyHugo) LTime() uint64 {
-	ch.mtx.Lock()
-	defer ch.mtx.Unlock()
-	ch.ltime++
-	return ch.ltime
+func (ch *CaddyHugo) logf(msg string, args ...interface{}) {
+	ch.logger.Info(fmt.Sprintf(msg, args...))
 }
 
+// Build rebuilds the cached state of the site. TODO: determine if this republishes
 func (ch *CaddyHugo) Build() error {
-	err := ch.HugoSites.Build(hugolib.BuildCfg{ResetState: true})
-	if err != nil {
-		return fmt.Errorf("error building hugo sites: %v", err)
-	}
-
-	return nil
+	return buildSite(ch.HugoSites)
 }
 
-func (ch *CaddyHugo) Setup(c *caddy.Controller) error {
-	var err error
-
-	ch.docs = make(map[string]*docref)
-	ch.Site = httpserver.GetConfig(c)
-
-	ch.HugoCfg = &deps.DepsCfg{}
-
-	ch.HugoCfg.Cfg, err = hugolib.LoadConfig(hugofs.Os, ch.Site.Root, "")
-	if err != nil {
-		return fmt.Errorf("error loading hugo config: %v", err)
-	}
-
-	ch.HugoCfg.Cfg.Set("workingdir", ch.Site.Root)
-	ch.HugoSites, err = hugolib.NewHugoSites(*ch.HugoCfg)
-	if err != nil {
-		return fmt.Errorf("error intializing hugo: %v", err)
-	}
-
-	err = ch.Build()
-	if err != nil {
-		return fmt.Errorf("error building initial hugo: %v", err)
-	}
-
-	ch.authorTmpl, err = template.New("").Parse(AuthorPage)
-	if err != nil {
-		return fmt.Errorf("author template invalid: %v", err)
-	}
-
-	ch.adminTmpl, err = template.New("").Parse(AdminPage)
-	if err != nil {
-		return fmt.Errorf("admin template invalid: %v", err)
-	}
-
-	ch.editTmpl, err = template.New("").Parse(EditPage)
-	if err != nil {
-		return fmt.Errorf("edit template invalid: %v", err)
-	}
-
-	thumbDir, err := ioutil.TempDir("", "thumbs")
-	if err != nil {
-		return fmt.Errorf("couldn't initialize media: %v", err)
-	}
-
-	ch.Media = &MediaSource{
-		StorageDir: path.Join(ch.Site.Root, "media"),
-		ThumbDir:   thumbDir,
-	}
-
-	err = os.MkdirAll(ch.Media.StorageDir, 0755)
-	if err != nil {
-		return fmt.Errorf("couldn't initialize media: %v", err)
-	}
-
-	// add a function that wraps listeners for the HTTP server
-	// (it's more common for a directive to call this rather than a standalone plugin)
-	ch.Site.AddMiddleware(ch.Middleware(c))
-
-	return ch.Publish()
-}
-
-func (ch *CaddyHugo) ServeHTTPWithNext(next httpserver.Handler, c *caddy.Controller, w http.ResponseWriter, r *http.Request) (int, error) {
-	if !ch.Match(r) {
-		p := path.Join(ch.Site.Root, "public", r.URL.Path)
-		http.ServeFile(w, r, p)
-		return 200, nil
-	}
-
-	if !ch.Auth(r) {
-		return http.StatusUnauthorized, errors.New("not authorized")
-	}
-
-	if strings.HasPrefix(r.URL.Path, "/hugo/publish") {
-		err := ch.Publish()
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return http.StatusInternalServerError, nil
-		}
-
-		http.Redirect(w, r, "/", http.StatusFound)
-		return http.StatusFound, nil
-	}
-	if strings.HasPrefix(r.URL.Path, "/hugo/simplemde.css") {
-		w.Write(assets.MustAsset("simplemde/dist/simplemde.min.css"))
-		return http.StatusOK, nil
-	}
-	if strings.HasPrefix(r.URL.Path, "/hugo/simplemde.js") {
-		w.Write(assets.MustAsset("simplemde/debug/simplemde.js"))
-		return http.StatusOK, nil
-	}
-	if strings.HasPrefix(r.URL.Path, "/hugo/admin") {
-		return ch.Admin().ServeHTTP(w, r)
-	}
-	if strings.HasPrefix(r.URL.Path, "/hugo/author") {
-		return ch.AuthorHome().ServeHTTP(w, r)
-	}
-	if strings.HasPrefix(r.URL.Path, "/hugo/edit/") {
-		return ch.Edit(c).ServeHTTP(w, r)
-	}
-	if strings.HasPrefix(r.URL.Path, "/hugo/draft/") {
-		return ch.serveDraft(w, r)
-	}
-	if strings.HasPrefix(r.URL.Path, "/hugo/media") {
-		return ch.serveMediaPage(w, r)
-	}
-	if strings.HasPrefix(r.URL.Path, "/hugo/upload") {
-		return ch.uploadMedia(w, r)
-	}
-	if strings.HasPrefix(r.URL.Path, "/media/") {
-		return ch.serveMedia(w, r)
-	}
-
-	http.NotFound(w, r)
-	return 404, nil
-}
-
-func (ch CaddyHugo) Middleware(c *caddy.Controller) httpserver.Middleware {
-	return func(next httpserver.Handler) httpserver.Handler {
-		return httpserver.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
-			return ch.ServeHTTPWithNext(next, c, w, r)
-		})
-	}
-}
-
-func (ch CaddyHugo) Auth(r *http.Request) bool {
-	return true
-}
-
-func (ch CaddyHugo) Match(r *http.Request) bool {
-	if strings.HasPrefix(r.URL.Path, "/media/") {
-		return true
-	}
-
-	if r.URL.Path == "/hugo" {
-		return true
-	}
-
-	return strings.HasPrefix(r.URL.Path, "/hugo/")
-}
-
-func (ch CaddyHugo) BasePath() string {
+// BasePath returns the directory that the CaddyHugo internal/author pages are under
+func (ch *CaddyHugo) BasePath() string {
 	return "/hugo"
 }
 
-func (ch CaddyHugo) Admin() httpserver.Handler {
-	return httpserver.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
-		err := ch.adminTmpl.Execute(w, ch.TmplData(r, nil))
-		if err != nil {
-			fmt.Println(err)
-			return http.StatusInternalServerError, err
-		}
-
-		return http.StatusOK, nil
-
-	})
+func docname(orig string) string {
+	orig = strings.Replace(orig, " ", "-", -1)
+	return strings.ToLower(orig)
 }
 
-func (ch CaddyHugo) AuthorHome() httpserver.Handler {
-	return httpserver.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
-		td := ch.TmplData(r, nil)
-		err := ch.authorTmpl.Execute(w, td)
-		if err != nil {
-			fmt.Println(err)
-			return http.StatusInternalServerError, err
-		}
-
-		return http.StatusOK, nil
-	})
+func (ch *CaddyHugo) docFilename(orig string) string {
+	return filepath.Join(ch.Dir, docname(orig))
 }
 
-func (ch *CaddyHugo) Edit(c *caddy.Controller) httpserver.Handler {
-	return httpserver.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
-		if r.URL.Path == "/hugo/edit/new" {
-			return ch.NewContent(w, r)
-		}
-
-		if r.Header.Get("Upgrade") == "websocket" {
-			return ch.DeltaWebsocket(w, r)
-		}
-
-		doc, err := ch.doc(r)
-		if err != nil {
-			fmt.Println(err)
-			return http.StatusNotFound, err
-		}
-
-		err = ch.editTmpl.Execute(w, ch.TmplData(r, doc))
-		if err != nil {
-
-			fmt.Println(err)
-			return http.StatusInternalServerError, err
-		}
-
-		return http.StatusOK, nil
-	})
-}
-
-func (ch *CaddyHugo) serveDraft(w http.ResponseWriter, r *http.Request) (int, error) {
-	pathSegments := strings.SplitN(r.URL.Path, "/", 5)
-	if len(pathSegments) < 4 {
-
-		return http.StatusNotFound, nil
-	}
-
-	encoded := pathSegments[3]
-
-	nameBytes, err := base64.RawURLEncoding.DecodeString(encoded)
-	if err != nil {
-		return http.StatusNotFound, err
-	}
-
-	name := string(nameBytes)
-
-	ch.mtx.Lock()
-	defer ch.mtx.Unlock()
-
-	docref, ok := ch.docs[name]
-	if !ok {
-		return http.StatusNotFound, fmt.Errorf("draft not found")
-	}
-
-	http.StripPrefix(
-		"/hugo/draft/"+encoded,
-		http.FileServer(http.Dir(docref.tmpdir))).ServeHTTP(w, r)
-	return 200, nil
-}
-
-func (ch *CaddyHugo) doc(r *http.Request) (*docref, error) {
-	ch.mtx.Lock()
-	defer ch.mtx.Unlock()
-
-	name := r.URL.Path[len("/hugo/edit/"):]
-	name = filepath.Join(ch.Site.Root, name)
-
-	_, ok := ch.docs[name]
-	if !ok {
-		fmt.Println("opening", name)
-		contents, err := ioutil.ReadFile(name)
-		if err != nil {
-			return nil, err
-		}
-
-		draftPrefix := fmt.Sprintf("draft-%s", base64.RawURLEncoding.EncodeToString([]byte(name)))
-		tmpdir := path.Join(os.TempDir(), draftPrefix)
-
-		ref := &docref{
-			name:   name,
-			doc:    acedoc.NewString(string(contents)),
-			tmpdir: tmpdir,
-		}
-
-		err = ref.doc.LogToFile(path.Join(ch.Site.Root, "logs", r.URL.Path[len("/hugo/edit/"):]))
-		if err != nil {
-			fmt.Println(err)
-			return nil, err
-		}
-
-		ch.docs[name] = ref
-
-		hugoCmd := exec.Command("hugo", "--watch", "-D", "-d", ref.tmpdir)
-		hugoCmd.Dir = ch.Site.Root
-		err = hugoCmd.Start()
-		if err != nil {
-			return nil, fmt.Errorf("error starting hugo: %v", err)
-		}
-
-		go func() {
-			ticker := time.NewTicker(WebsocketFileTicker)
-			idleTicks := 0
-
-			defer func() {
-				err := hugoCmd.Process.Signal(os.Interrupt)
-				if err != nil {
-					fmt.Println("error signaling to hugo:", err)
-				}
-				err = hugoCmd.Wait()
-				if err != nil {
-					fmt.Println("error waiting for hugo:", err)
-				}
-			}()
-
-			for {
-				<-ticker.C
-				ch.mtx.Lock()
-
-				err := ioutil.WriteFile(name, []byte(ref.doc.Contents()), 0644)
-				if err != nil {
-					fmt.Println("error saving document contents:", err)
-				}
-
-				if ref.clients == 0 {
-					idleTicks++
-					idleTime := time.Duration(idleTicks) * WebsocketFileTicker
-					if idleTime >= IdleWebsocketTimeout {
-						err := ch.Publish()
-						fmt.Printf("idle for %v, quitting\n", idleTime)
-						if err != nil {
-							fmt.Printf(", error publishing: %v\n", err)
-						}
-
-						ref.doc.Close()
-						os.RemoveAll(tmpdir)
-						delete(ch.docs, name)
-						ch.mtx.Unlock()
-						return
-					}
-				} else {
-					idleTicks = 0
-				}
-				ch.mtx.Unlock()
-			}
-		}()
-	}
-
-	return ch.docs[name], nil
-}
-
-func (ch *CaddyHugo) Publish() error {
-	cmd := exec.Command("hugo")
-	cmd.Dir = ch.Site.Root
-	_, err := cmd.CombinedOutput()
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (ch *CaddyHugo) DeltaWebsocket(w http.ResponseWriter, r *http.Request) (int, error) {
-	var upgrader = websocket.Upgrader{
-		ReadBufferSize:  1024,
-		WriteBufferSize: 1024,
-	}
-
-	conn, err := upgrader.Upgrade(w, r, nil)
-	if err != nil {
-		fmt.Println(err)
-		return http.StatusBadRequest, err
-	}
-
-	doc, err := ch.doc(r)
-	if err != nil {
-		fmt.Println(err)
-		return http.StatusBadRequest, err
-	}
-
-	const idlePing = 15 * time.Second
-	const idlePingShort = 1 * time.Millisecond
-	var timer *time.Timer
-
-	timer = time.AfterFunc(idlePing, func() {
-		conn.WriteJSON(Message{
-			Deltas: []acedoc.Delta{},
-			LTime:  ch.LTime(),
-		})
-		timer.Reset(idlePing)
-	})
-
-	client := doc.doc.Client(acedoc.DeltaHandlerFunc(func(ds []acedoc.Delta) error {
-		timer.Reset(idlePing)
-		err := conn.WriteJSON(Message{
-			Deltas: ds,
-			LTime:  ch.LTime(),
-		})
-		return err
-	}))
-
-	ch.mtx.Lock()
-	doc.clients++
-	ch.mtx.Unlock()
-
-	defer func() {
-		ch.mtx.Lock()
-		client.Close()
-		doc.clients--
-		ch.mtx.Unlock()
-	}()
-
-	for {
-		var message Message
-		err := conn.ReadJSON(&message)
-		if err != nil {
-			return http.StatusBadRequest, err
-		}
-
-		ch.ObserveLTime(message.LTime)
-		timer.Reset(idlePingShort)
-
-		err = client.PushDeltas(message.Deltas...)
-		if err != nil {
-			return http.StatusBadRequest, err
-		}
-
-	}
-}
-
-type Message struct {
-	Deltas []acedoc.Delta `json:"deltas"`
-	LTime  uint64         `json:"ltime"`
-}
-
-func (ch CaddyHugo) NewContent(w http.ResponseWriter, r *http.Request) (int, error) {
-	name := r.FormValue("name")
-	ctype := r.FormValue("type")
-
-	if filepath.Ext(name) != ".md" {
-		name += ".md"
-	}
-
-	filename := path.Join(ctype, name)
-	if ctype == "default" {
-		filename = name
-	}
-
-	cmd := exec.Command("hugo", "new", filename)
-	cmd.Dir = ch.Site.Root
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		fmt.Println("error running hugo:\n", string(out))
-		return http.StatusInternalServerError, err
-	}
-
-	// serve redirect
-	http.Redirect(w, r, filepath.Join("/hugo/edit/", "content", filename), http.StatusFound)
-	return http.StatusFound, nil
-}
-
-func (ch CaddyHugo) TmplData(r *http.Request, docref *docref) interface{} {
+// TmplData collects data for template execution
+func (ch *CaddyHugo) TmplData(r *http.Request, docref *editSession) interface{} {
 	var doc *acedoc.Document
 	if docref != nil {
 		doc = docref.doc
@@ -532,5 +145,16 @@ func (ch CaddyHugo) TmplData(r *http.Request, docref *docref) interface{} {
 		ch.HugoSites.Fs.Destination = afero.NewMemMapFs()
 		ch.Build()
 	}
-	return tmplData{ch.Site, r, ch, doc, docref}
+	return &tmplData{ch.Site, r, ch, doc, docref}
 }
+
+// parseCaddyfile unmarshals tokens from h into a new Middleware.
+func parseCaddyfile(h httpcaddyfile.Helper) (caddyhttp.MiddlewareHandler, error) {
+	var m CaddyHugo
+	err := m.Site.UnmarshalCaddyfile(h.Dispenser)
+	return &m, err
+}
+
+var (
+	_ caddy.Provisioner = (*CaddyHugo)(nil)
+)

client.go

@@ -0,0 +1,129 @@
+package caddyhugo
+
+import (
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"path"
+	"sync"
+
+	"github.com/spf13/afero"
+
+	"git.stephensearles.com/stephen/acedoc"
+	"git.stephensearles.com/stephen/idleshut"
+)
+
+type editSession struct {
+	clients  uint
+	docname  string
+	filename string
+	doc      *acedoc.Document
+	tmpfs    afero.Fs
+	mtx      sync.Mutex
+}
+
+func (es *editSession) Clients() uint {
+	es.mtx.Lock()
+	defer es.mtx.Unlock()
+
+	return es.clients
+}
+
+func (ch *CaddyHugo) newEditSession(docName string) (*editSession, error) {
+	filename := ch.docFilename(docName)
+
+	fmt.Println("opening", filename)
+	contents, err := ioutil.ReadFile(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	tmpfs := afero.NewCopyOnWriteFs(afero.NewOsFs(), afero.NewMemMapFs())
+
+	es := &editSession{
+		docname:  docName,
+		filename: filename,
+		doc:      acedoc.NewString(string(contents)),
+		tmpfs:    tmpfs,
+	}
+
+	err = es.doc.LogToFile(path.Join(ch.Dir, "logs", docName))
+	if err != nil {
+		fmt.Println(err)
+		return nil, err
+	}
+
+	ch.docs[filename] = es
+
+	err = ch.renderDraft(es)
+	if err != nil {
+		return nil, err
+	}
+
+	return es, nil
+}
+
+func (ch *CaddyHugo) renderDraft(es *editSession) error {
+	var proc *idleshut.Process
+
+	f := func() {
+		if es.clients != 0 {
+			proc.Touch()
+		}
+	}
+
+	cfg, err := HugoInternalProcessConfig(ch, es, f)
+	if err != nil {
+		return fmt.Errorf("rendering draft: %v", err)
+	}
+
+	proc = idleshut.New(cfg)
+	return proc.Start()
+}
+
+func (ch *CaddyHugo) persistAllEdits() error {
+	ch.mtx.Lock()
+	defer ch.mtx.Unlock()
+	for _, es := range ch.docs {
+		err := ch.persistEditsForSession(es)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (ch *CaddyHugo) persistEditsForSession(es *editSession) error {
+	err := afero.WriteFile(afero.NewOsFs(), es.filename, []byte(es.doc.Contents()), 0644)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (ch *CaddyHugo) hasEditSession(docName string) (*editSession, bool) {
+	dr, ok := ch.docs[ch.docFilename(docName)]
+	return dr, ok
+}
+
+func (ch *CaddyHugo) editSession(docName string) (*editSession, error) {
+	ch.mtx.Lock()
+	defer ch.mtx.Unlock()
+
+	var err error
+
+	dr, ok := ch.hasEditSession(docName)
+	if !ok {
+		dr, err = ch.newEditSession(docName)
+	}
+
+	return dr, err
+}
+
+func docNameFromEditRequest(r *http.Request) string {
+	return r.URL.Path[len("/hugo/edit/"):]
+}
+
+func docNameFromCommentRequest(r *http.Request) string {
+	return r.URL.Path[1 : len(r.URL.Path)-len("/comments")]
+}

comments/comments.go

@@ -0,0 +1,314 @@
+package comments
+
+import (
+	"bytes"
+	"crypto/subtle"
+	"encoding/json"
+	"fmt"
+	"html/template"
+	"io"
+	"net/http"
+	"strconv"
+	"sync"
+	"time"
+
+	"github.com/peterbourgon/diskv"
+)
+
+type Comment struct {
+	Name, Text string
+	IP         string
+	Date       time.Time
+	Spam       bool
+}
+
+func MarshalJSON(c Comment) ([]byte, error) {
+	buf := new(bytes.Buffer)
+	err := json.NewEncoder(buf).Encode(c)
+	return buf.Bytes(), err
+}
+
+func UnmarshalJSON(b []byte) (Comment, error) {
+	var c Comment
+	err := json.NewDecoder(bytes.NewBuffer(b)).Decode(&c)
+	return c, err
+}
+
+func Default() *Service {
+	return WithStorage(NewDiskv("comments"))
+}
+
+func WithStorage(storage Storage) *Service {
+	return &Service{Storage: storage}
+}
+
+type Service struct {
+	Storage  Storage
+	Password string
+}
+
+type Storage interface {
+	Store(post string, c Comment) error
+	Retreive(post string) ([]Comment, error)
+	ReadAll(post string) (io.Reader, error)
+}
+
+func (cs *Service) User(r *http.Request) (string, bool) {
+	if cs.Password == "" {
+		return "", true
+	}
+
+	user, providedPass, ok := r.BasicAuth()
+	if ok && subtle.ConstantTimeCompare([]byte(cs.Password), []byte(providedPass)) == 1 {
+		return user, true
+	}
+
+	return "", false
+}
+
+func (cs *Service) ServeComments(post string, w http.ResponseWriter, r *http.Request) error {
+	user, allowed := cs.User(r)
+	if !allowed {
+		fmt.Fprintf(w, "<a href='/login'>click here to enter your name and the comments password</a>")
+		w.WriteHeader(401)
+		return nil
+	}
+
+	if r.Method == "POST" {
+		return cs.Comment(post, Comment{
+			Name: user,
+			Text: readCommentText(r),
+			IP:   r.RemoteAddr,
+			Date: time.Now(),
+		})
+	}
+
+	w.Header().Set("Content-Type", "text/html")
+	_, err := cs.WriteHTML(post, w)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func readCommentText(r *http.Request) string {
+	comment := struct{ Text string }{}
+	json.NewDecoder(r.Body).Decode(&comment)
+	return comment.Text
+}
+
+func (cs *Service) Comment(post string, c Comment) error {
+	return cs.Storage.Store(post, c)
+}
+
+func (cs *Service) Load(post string) ([]Comment, error) {
+	return cs.Storage.Retreive(post)
+}
+
+func (cs *Service) WriteHTML(post string, w io.Writer) (int64, error) {
+	buf := &bytes.Buffer{}
+	tmpl := template.Must(template.New("").Parse(
+		`<style>
+		comment {
+			margin: 10px 0;
+		}
+		comment, comment name, comment text {
+			display: block;
+		}
+		comment name::after {
+			content: " says:";
+		}
+		comment text {
+			margin-left: 5px;
+			padding-left: 5px;
+			border-left: 2px solid gray;
+		}
+		</style>
+		{{range .}}{{ if .Text }}<comment>
+		<name>{{.Name}}</name>
+		<text>{{.Text}}</text>
+		</comment>
+		{{end}}{{end}}
+		<form onsubmit="submitComment(event)">
+		<p>
+			<div>
+			<label for="comment">post a comment:</label>
+			</div>
+			<div>
+			<textarea placeholder="comment..." name="comment"></textarea>
+			</div>
+			<div>
+			<button type="submit">post</button>
+			</div>
+		</p>
+		</form>`))
+
+	comments, err := cs.Load(post)
+	if err != nil {
+		return 0, err
+	}
+
+	err = tmpl.Execute(buf, comments)
+	if err != nil {
+		return 0, err
+	}
+	return io.Copy(w, buf)
+}
+
+func (cs *Service) WriteJSON(post string, w io.Writer) (int64, error) {
+	r, err := cs.Storage.ReadAll(post)
+	if err != nil {
+		return 0, err
+	}
+
+	return io.Copy(w, r)
+}
+
+type diskvStorage struct {
+	*diskv.Diskv
+
+	keyMtx       sync.Mutex
+	keyLastKnown int64
+}
+
+func (d *diskvStorage) nextKey(post string) (string, error) {
+	d.keyMtx.Lock()
+	defer d.keyMtx.Unlock()
+
+	prefix := post + "-"
+
+	lastKey := prefix
+
+	keys := d.KeysPrefix(prefix, nil)
+	for key := range keys {
+		lastKey = key
+	}
+
+	if lastKey == prefix {
+		return prefix + "1", nil
+	}
+
+	minusPrefix := lastKey[len(prefix):]
+	lastIdx, err := strconv.Atoi(minusPrefix)
+	if err != nil {
+		return "", fmt.Errorf("comment key %q seems malformed", lastKey)
+	}
+
+	key := prefix + fmt.Sprint(lastIdx+1)
+	err = d.WriteStream(key, &bytes.Buffer{}, true)
+
+	return key, err
+}
+
+func (d *diskvStorage) Store(post string, c Comment) error {
+	b, err := MarshalJSON(c)
+	if err != nil {
+		return fmt.Errorf("error marshaling comment for storage: %v", err)
+	}
+
+	key, err := d.nextKey(post)
+	if err != nil {
+		return fmt.Errorf("error recording comment: %v", err)
+	}
+
+	err = d.Write(key, b)
+	if err != nil {
+		return fmt.Errorf("error writing comment to storage: %v", err)
+	}
+
+	return nil
+}
+
+type multiReadCloser struct {
+	rcs []io.ReadCloser
+}
+
+func (mrc *multiReadCloser) Read(b []byte) (int, error) {
+	if len(mrc.rcs) == 0 {
+		return 0, io.EOF
+	}
+
+	n, err := mrc.rcs[0].Read(b)
+	if n == len(b) { // we read enough
+		return n, err
+	}
+
+	for (err == nil || err == io.EOF) && len(mrc.rcs) > 1 {
+		var n2 int
+		closeErr := mrc.rcs[0].Close()
+		if closeErr != nil {
+			return n, closeErr
+		}
+
+		mrc.rcs = mrc.rcs[1:]
+		n2, err = mrc.rcs[0].Read(b[n:])
+		n += n2
+	}
+
+	return n, err
+}
+
+func (mrc *multiReadCloser) Close() error {
+	var err error
+
+	for _, rc := range mrc.rcs {
+		err2 := rc.Close()
+		if err2 != nil {
+			err = err2
+		}
+	}
+
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (d *diskvStorage) ReadAll(post string) (io.Reader, error) {
+	prefix := post + "-"
+
+	var rcs []io.ReadCloser
+
+	keys := d.KeysPrefix(prefix, nil)
+	for key := range keys {
+		rc, err := d.ReadStream(key, false)
+		if err != nil {
+			return nil, err
+		}
+		rcs = append(rcs, rc)
+	}
+
+	return &multiReadCloser{rcs}, nil
+}
+
+func (d *diskvStorage) Retreive(post string) ([]Comment, error) {
+	var comments []Comment
+
+	r, err := d.ReadAll(post)
+	if err != nil {
+		return comments, fmt.Errorf("error reading comment from storage: %v", err)
+	}
+
+	dec := json.NewDecoder(r)
+	for dec.More() {
+		comment := Comment{}
+		err := dec.Decode(&comment)
+		if err != nil {
+			return comments, fmt.Errorf("error unmarshaling comment: %v", err)
+		}
+		comments = append(comments, comment)
+	}
+
+	return comments, nil
+}
+
+func NewDiskv(path string) Storage {
+	return &diskvStorage{
+		Diskv: diskv.New(diskv.Options{
+			BasePath:     path,
+			CacheSizeMax: 1024 * 1024,
+		}),
+	}
+}

content.go

@@ -0,0 +1,111 @@
+package caddyhugo
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path"
+	"path/filepath"
+	"sort"
+	"time"
+
+	"github.com/gohugoio/hugo/hugolib"
+)
+
+type Content struct {
+	Filename string
+	Modtime  time.Time
+	Metadata *Metadata
+}
+
+type Metadata struct {
+	Title         string
+	Path          string
+	Date, Lastmod time.Time
+}
+
+// GetContent fetches the list of available content from the site directory. If
+// possible, the return value will be enriched with metadata from Hugo.
+func GetContent(siteRoot string, sites *hugolib.HugoSites) ([]Content, error) {
+	var files = []Content{}
+
+	err := filepath.Walk(path.Join(siteRoot, "content"), func(name string, fi os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if fi.IsDir() {
+			return nil
+		}
+
+		name, err = filepath.Rel(siteRoot, name)
+		if err != nil {
+			return err
+		}
+
+		files = append(files, Content{
+			Filename: name,
+			Modtime:  fi.ModTime(),
+		})
+		return nil
+	})
+
+	sort.Slice(files, func(i, j int) bool {
+		return files[i].Modtime.Before(files[j].Modtime)
+	})
+
+	if err != nil {
+		fmt.Println(err)
+		return nil, err
+	}
+
+	for i, file := range files {
+		fn := path.Join(siteRoot, file.Filename)
+		page := sites.GetContentPage(fn)
+		if page != nil {
+			files[i].Metadata = &Metadata{
+				Title:   page.Title(),
+				Path:    file.Filename,
+				Date:    page.Date(),
+				Lastmod: page.Lastmod(),
+			}
+		}
+	}
+
+	return files, nil
+}
+
+// NewContent initializes new content with the name (title) and content type.
+// If ctype is empty string, "default" is used. The return value is the filename,
+// which may be modified from the title and includes the content type if other than
+// default, but does not include the full directory relative to the site.
+func (ch *CaddyHugo) NewContent(name, ctype string) (string, error) {
+	if filepath.Ext(name) != ".md" {
+		name += ".md"
+	}
+
+	if ctype == "" {
+		ctype = "default"
+	}
+
+	name = docname(name)
+	filename := path.Join(ctype, name)
+	if ctype == "default" {
+		filename = name
+	}
+
+	_, err := os.Stat(path.Join(ch.Dir, "content", filename))
+	if os.IsNotExist(err) {
+		cmd := exec.Command("hugo", "new", filename)
+		cmd.Dir = ch.Dir
+		ch.logf("running `hugo new` in %v", ch.Dir)
+		out, err := cmd.CombinedOutput()
+		if err != nil {
+			return filename, fmt.Errorf("error running 'hugo new': %v; %v", err, string(out))
+		}
+	}
+
+	ch.Build()
+
+	return filename, nil
+}

deltas.go

@@ -0,0 +1,236 @@
+package caddyhugo
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"time"
+
+	"git.stephensearles.com/stephen/acedoc"
+	"github.com/gorilla/websocket"
+)
+
+// DeltaConn identifies the methods used in the original websocket implementation.
+type DeltaConn interface {
+	ReadJSON(v interface{}) error
+	WriteJSON(v interface{}) error
+}
+
+func (ch *CaddyHugo) ObserveLTime(ltime uint64) uint64 {
+	ch.mtx.Lock()
+
+	if ch.ltime < ltime {
+		ch.ltime = ltime
+	}
+
+	ch.mtx.Unlock()
+	return ch.LTime()
+}
+
+func (ch *CaddyHugo) LTime() uint64 {
+	ch.mtx.Lock()
+	defer ch.mtx.Unlock()
+	ch.ltime++
+	return ch.ltime
+}
+
+func (ch *CaddyHugo) ShouldApply(ltime uint64) bool {
+
+	ch.mtx.Lock()
+	defer ch.mtx.Unlock()
+
+	if _, ok := ch.confirmingToClient[ltime]; ok {
+		return false
+	}
+
+	return true
+}
+
+// ConfirmLTime marks an ltime as something that should be confirmed with clients
+func (ch *CaddyHugo) ConfirmLTime(ltime uint64) {
+	ch.mtx.Lock()
+	defer ch.mtx.Unlock()
+	ch.confirmingToClient[ltime] = struct{}{}
+}
+
+// Confirming returns the current list of LTimes that need to be confirmed
+// to clients
+func (ch *CaddyHugo) Confirming() []uint64 {
+	var times []uint64
+
+	ch.mtx.Lock()
+	defer ch.mtx.Unlock()
+
+	for ltime := range ch.confirmingToClient {
+		times = append(times, ltime)
+	}
+	return times
+}
+
+// LowestPendingConfirmation identifies the lowest LTime that needs to be
+// confirmed to clients
+func (ch *CaddyHugo) LowestPendingConfirmation() uint64 {
+	var lowest uint64
+	for _, c := range ch.Confirming() {
+		if lowest == 0 || c < lowest {
+			lowest = c
+		}
+	}
+	return lowest
+}
+
+func (ch *CaddyHugo) ClearConfirmed(lowestPending uint64) {
+	ch.mtx.Lock()
+	defer ch.mtx.Unlock()
+
+	for ltime := range ch.confirmingToClient {
+		if ltime < lowestPending {
+			delete(ch.confirmingToClient, ltime)
+		}
+	}
+}
+
+func (ch *CaddyHugo) DeltaWebsocket(w http.ResponseWriter, r *http.Request) error {
+	var upgrader = websocket.Upgrader{
+		ReadBufferSize:  1024,
+		WriteBufferSize: 1024,
+	}
+
+	conn, err := upgrader.Upgrade(w, r, nil)
+	if err != nil {
+		fmt.Println(err)
+		return err
+	}
+
+	conn.SetReadDeadline(time.Time{})
+
+	doc, err := ch.editSession(docNameFromEditRequest(r))
+	if err != nil {
+		fmt.Println(err)
+		return err
+	}
+
+	return ch.handleDeltaConn(conn, doc)
+}
+
+func (ch *CaddyHugo) Message(deltas ...acedoc.Delta) Message {
+	return Message{
+		Deltas:        deltas,
+		LTime:         ch.LTime(),
+		Confirmed:     ch.Confirming(),
+		LowestPending: ch.LowestPendingConfirmation(),
+	}
+}
+
+func (ch *CaddyHugo) handleDeltaConn(conn DeltaConn, doc *editSession) error {
+	const idlePing = 15 * time.Second
+	const idlePingShort = 1 * time.Millisecond
+
+	errCh := make(chan error)
+	doneCh := make(chan struct{})
+	defer func() {
+		close(doneCh)
+		close(errCh)
+		for err := range errCh {
+			log.Println(err)
+		}
+	}()
+
+	timer := time.NewTimer(idlePing)
+	resetTimer := func(d time.Duration) {
+		if !timer.Stop() {
+			select {
+			case <-timer.C:
+			default:
+			}
+		}
+		timer.Reset(d)
+	}
+
+	wroteMessagesCh := make(chan Message, 2)
+
+	client := doc.doc.Client(acedoc.DeltaHandlerFunc(func(ds []acedoc.Delta) error {
+		m := ch.Message(ds...)
+		wroteMessagesCh <- m
+		return conn.WriteJSON(m)
+	}))
+
+	ch.mtx.Lock()
+	doc.clients++
+	ch.mtx.Unlock()
+
+	defer func() {
+		ch.mtx.Lock()
+		client.Close()
+		doc.clients--
+		ch.mtx.Unlock()
+	}()
+
+	readMessagesCh := make(chan Message, 2)
+	go func() {
+		for {
+			var message Message
+
+			err := conn.ReadJSON(&message)
+			if err != nil {
+				errCh <- fmt.Errorf("error reading message from client conn: %v", err)
+				return
+			}
+			if message.LTime != 0 {
+				ch.ObserveLTime(message.LTime)
+			}
+
+			if len(message.Deltas) == 0 {
+				continue
+			}
+
+			if !ch.ShouldApply(message.LTime) {
+				continue
+			}
+
+			err = client.PushDeltas(message.Deltas...)
+			if err != nil {
+				errCh <- fmt.Errorf("error pushing deltas into document: %v", err)
+				return
+			}
+
+			ch.ConfirmLTime(message.LTime)
+			ch.ClearConfirmed(message.LowestPending)
+
+			select {
+			case readMessagesCh <- message:
+			case <-doneCh:
+				return
+			}
+
+		}
+	}()
+
+	for {
+		select {
+		case err := <-errCh:
+			fmt.Println("error handling websocket connection:", err)
+			return err
+		default:
+		}
+
+		select {
+		case <-timer.C:
+			conn.WriteJSON(ch.Message())
+			resetTimer(idlePing)
+		case <-readMessagesCh:
+			resetTimer(idlePingShort)
+		case <-wroteMessagesCh:
+			resetTimer(idlePing)
+		case <-doneCh:
+			return nil
+		}
+	}
+}
+
+type Message struct {
+	Deltas        []acedoc.Delta `json:"deltas"`
+	LTime         uint64         `json:"ltime"`
+	Confirmed     []uint64       `json:"confirmed"`
+	LowestPending uint64         `json:"lowestPending"`
+}

doc_test.go

@@ -0,0 +1,296 @@
+package caddyhugo
+
+import (
+	"path"
+	"sync"
+	"testing"
+	"time"
+
+	"git.stephensearles.com/stephen/acedoc"
+)
+
+func TestEdits(t *testing.T) {
+	w := NewWorld(t)
+	defer w.Clean()
+
+	const title = "sometitle"
+
+	var (
+		mtx sync.Mutex
+
+		contentPath = path.Join("content", title+".md")
+
+		// we will send these to the doc
+		send = []acedoc.Delta{
+			acedoc.Insert(0, 0, "hello"),
+			acedoc.Insert(0, 5, " world"),
+			acedoc.Insert(0, 11, " world"),
+		}
+
+		// we will use this to track what we get out of the doc
+		received = []acedoc.Delta{}
+	)
+
+	// prepare a new post
+	w.CH.NewContent(title, "")
+
+	// start an edit session
+	es, err := w.CH.editSession(contentPath)
+	if err != nil {
+		t.Fatal("error creating document client:", err)
+	}
+
+	// register a client that we will use to push the deltas. we dont need
+	// to actually do anything to receive deltas here, though.
+	c := es.doc.Client(acedoc.DeltaHandlerFunc(func(ds []acedoc.Delta) error {
+		return nil
+	}))
+
+	// register an *extra* client that just adds to the received delta
+	// slice we're tracking
+	es.doc.Client(acedoc.DeltaHandlerFunc(func(ds []acedoc.Delta) error {
+		mtx.Lock()
+		defer mtx.Unlock()
+		received = append(received, ds...)
+		return nil
+	}))
+
+	// make sure we have an edit session
+	_, ok := w.CH.hasEditSession(contentPath)
+	if !ok {
+		t.Fatal("expected there to be an established client")
+	}
+
+	// push the deltas
+	c.PushDeltas(send...)
+
+	// wait...
+	<-time.After(5 * time.Second)
+
+	// be sure we got the correct number of deltas back
+	mtx.Lock()
+	defer mtx.Unlock()
+	if len(received) != len(send) {
+		t.Errorf("expected %d deltas, received %d; expected: %v, received: %v", len(send), len(received), send, received)
+	}
+}
+
+func TestDeltasSingle(t *testing.T) {
+	w := NewWorld(t)
+	defer w.Clean()
+
+	const title = "test"
+
+	_, err := w.CH.NewContent(title, "")
+	if err != nil {
+		t.Fatal("couldn't create new content:", err)
+	}
+
+	client := new(WebsocketTester)
+
+	es, err := w.CH.editSession("content/" + title + ".md")
+	if err != nil {
+		t.Fatal("couldn't establish docref for client 0:", err)
+	}
+
+	go w.CH.handleDeltaConn(client, es)
+
+	a := acedoc.Insert(0, 0, "a")
+
+	// pretend to get one sent from the "browser"
+	client.ReceiveJSON(w.CH.Message(a))
+
+	// wait to make sure it was processed
+	time.Sleep(50 * time.Millisecond)
+
+	// we shouldn't have written back to the client,
+	// so we expect to have written 0 *deltas*. (we may have written
+	// empty messages without deltas because of the pings to the client)
+	if len(client.wroteDeltas) != 0 {
+		t.Errorf("client wrote %d deltas, should have written %d", len(client.wroteMessages), 0)
+		t.Logf("%v", client.wroteMessages)
+	}
+
+	// we received one, so make sure that's counted properly
+	if len(client.received) != 1 {
+		t.Errorf("client has %d messages, should have received %d", len(client.received), 1)
+	}
+}
+
+func TestDeltasDouble(t *testing.T) {
+	w := NewWorld(t)
+	defer w.Clean()
+
+	const title = "test"
+
+	_, err := w.CH.NewContent(title, "")
+	if err != nil {
+		t.Fatal("couldn't create new content:", err)
+	}
+
+	clientA := new(WebsocketTester)
+	clientB := new(WebsocketTester)
+
+	doc, err := w.CH.editSession("content/" + title + ".md")
+	if err != nil {
+		t.Fatal("couldn't establish docref for client 0:", err)
+	}
+
+	go w.CH.handleDeltaConn(clientA, doc)
+	go w.CH.handleDeltaConn(clientB, doc)
+
+	// send the first message, simulating the browser on clientA
+	clientA.ReceiveJSON(w.CH.Message(acedoc.Insert(0, 0, "a")))
+
+	time.Sleep(100 * time.Millisecond)
+
+	clientA.mtx.Lock()
+	clientB.mtx.Lock()
+
+	// so we expect clientA to have written 0 messages, and
+	// clientB to have written 1
+	if len(clientA.wroteDeltas) != 0 || len(clientB.wroteDeltas) != 1 {
+		t.Errorf("clientA wrote %d messages, should have written 0. clientB wrote %d, should have written 1", len(clientA.wroteMessages), len(clientB.wroteMessages))
+	}
+
+	// we received one via clientA and zero via clientB, so make sure
+	// that's counted properly
+	if len(clientA.received) != 1 || len(clientB.received) != 0 {
+		t.Errorf("clientA has %d messages, should have received 1; clientB has %d messages, should have received 0", len(clientA.received), len(clientB.received))
+	}
+
+	clientA.mtx.Unlock()
+	clientB.mtx.Unlock()
+
+	// send the second message, via clientB
+	clientB.ReceiveJSON(w.CH.Message(acedoc.Insert(0, 0, "b")))
+
+	time.Sleep(400 * time.Millisecond)
+
+	clientA.mtx.Lock()
+	clientB.mtx.Lock()
+
+	// so we expect clientA to have written 1 delta this time, and
+	// clientB to have written nothing new, so 1 still
+	if len(clientA.wroteDeltas) != 1 || len(clientB.wroteDeltas) != 1 {
+		t.Errorf("clientA wrote %d messages, should have written 1. clientB wrote %d, should have written 1 (just from before)", len(clientA.wroteMessages), len(clientB.wroteMessages))
+	}
+
+	// we received zero (new) via clientA and one via clientB, so make sure
+	// that's counted properly
+	if len(clientA.received) != 1 || len(clientB.received) != 1 {
+		t.Errorf("clientA has %d messages, should have received 1; clientB has %d messages, should have received 1", len(clientA.received), len(clientB.received))
+	}
+	clientA.mtx.Unlock()
+	clientB.mtx.Unlock()
+}
+
+func TestDeltasMulti(t *testing.T) {
+	w := NewWorld(t)
+	defer w.Clean()
+
+	const title = "test"
+
+	_, err := w.CH.NewContent(title, "")
+	if err != nil {
+		t.Fatal("couldn't create new content:", err)
+	}
+
+	clients := []*WebsocketTester{{}, {}, {}}
+
+	doc, err := w.CH.editSession("content/" + title + ".md")
+	if err != nil {
+		t.Fatal("couldn't establish edit session:", err)
+	}
+
+	go w.CH.handleDeltaConn(clients[0], doc)
+	go w.CH.handleDeltaConn(clients[1], doc)
+	go w.CH.handleDeltaConn(clients[2], doc)
+
+	time.Sleep(100 * time.Millisecond)
+
+	a := acedoc.Insert(0, 0, "a")
+	b := acedoc.Insert(0, 0, "b")
+	c := acedoc.Insert(0, 0, "c")
+
+	clients[0].ReceiveJSON(w.CH.Message(a))
+	clients[1].ReceiveJSON(w.CH.Message(b))
+	clients[2].ReceiveJSON(w.CH.Message(c))
+
+	time.Sleep(1000 * time.Millisecond)
+
+	for i, client := range clients {
+		client.mtx.Lock()
+		// all clients should have "written" 2 deltas out to their "browser"
+		// that came from the other clients
+		if len(client.wroteDeltas) != 2 {
+			t.Errorf("client %d wrote %d deltas, should have written 2", i, len(client.wroteDeltas))
+		}
+
+		// all clients "received" 1 message from the "browser"
+		if len(client.received) != 1 {
+			t.Errorf("client %d has %d messages, should have received 1", i, len(client.received))
+		}
+		client.mtx.Unlock()
+	}
+}
+
+func TestPagesInPagesOut(t *testing.T) {
+	w := NewWorld(t)
+	defer w.Clean()
+
+	// check there's no content at first
+	c, err := GetContent(w.BlogFolder, w.CH.HugoSites)
+	if err != nil {
+		t.Fatalf("couldn't get content from a blank test environment: %v", err)
+	}
+	if len(c) != 0 {
+		t.Fatalf("expected a blank test environment, but saw %d pages", len(c))
+	}
+
+	titles := []string{
+		"test1",
+		"TEST 2!!",
+	}
+
+	found := map[string]bool{}
+
+	// create some known content
+	for i, title := range titles {
+		w.CH.NewContent(title, "")
+		c, err = GetContent(w.BlogFolder, w.CH.HugoSites)
+		if err != nil {
+			t.Fatalf("couldn't get content from the test environment: %v", err)
+		}
+		if len(c)-1 != i {
+			t.Fatalf("expected %d page, but saw %d pages", i+1, len(c))
+		}
+
+	}
+
+	// make sure we get the content out that we just created
+	c, err = GetContent(w.BlogFolder, w.CH.HugoSites)
+	if err != nil {
+		t.Fatalf("couldn't get content from the test environment: %v", err)
+	}
+
+	for _, content := range c {
+		if content.Metadata == nil {
+			t.Errorf("didn't see metadata for %q", content.Filename)
+		}
+		found[content.Filename] = true
+	}
+
+	var missingSomething bool
+	for _, title := range titles {
+		adjusted := path.Join("content", docname(title)+".md")
+		if !found[adjusted] {
+			missingSomething = true
+			t.Errorf("expected to find title %q, but didn't see it", adjusted)
+		}
+	}
+
+	if missingSomething {
+		t.Logf("found titles: %v", found)
+	}
+}

frontend/templates.go

@@ -0,0 +1,30 @@
+package frontend
+
+import "embed"
+
+//go:embed templates
+var templates embed.FS
+
+func readFilename(filename string) string {
+	f, err := templates.ReadFile(filename)
+	if err != nil {
+		panic(err)
+	}
+	return string(f)
+}
+
+func EditPage() string {
+	return readFilename("templates/edit.html.tmpl")
+}
+
+func AdminPage() string {
+	return readFilename("templates/admin.html.tmpl")
+}
+
+func AuthorPage() string {
+	return readFilename("templates/author.html.tmpl")
+}
+
+func UploadPage() string {
+	return readFilename("templates/upload.html.tmpl")
+}

frontend/templates/admin.html.tmpl

@@ -0,0 +1 @@
+<html><body>not implemented</body></html>

frontend/templates/author.html.tmpl

@@ -0,0 +1,44 @@
+<html>
+<head>
+</head>
+<body>
+{{ $timeFormat := "Jan _2 15:04:05" }}
+	<p>Create content:</p>
+	<form action="/hugo/edit/new" method="POST">
+		<label>Name: <input type="text" name="name" /></label>
+		<select name="type">
+		    {{- range .ContentTypes }}
+			<option value="{{ . }}">{{ . }}</option>
+		    {{- end }}
+		</select>
+		<input type="submit" />
+	</form>
+
+	<p>Edit content:</p>
+	<table>{{ range .Content }}
+	<tr>
+		{{ if .Metadata }}
+			<td>
+				<a href="/hugo/edit/{{ .Filename }}">
+				{{ .Metadata.Title }}
+				</a>
+			</td>
+			<td>
+				{{ .Metadata.Date.Format $timeFormat }}
+				{{ if not (.Metadata.Lastmod.Equal .Metadata.Date) }}
+				(last modified {{.Metadata.Lastmod.Format $timeFormat }})
+				{{end}}
+			</td>
+		{{ else }}
+			<td>
+				<a href="/hugo/edit/{{ .Filename }}">
+				{{ .Filename }}
+				</a>
+			</td>
+			<td>(unable to load metadata)</td>
+		{{ end }}
+	</tr>
+	{{- end }}
+	</table>
+</body>
+</html>

frontend/templates/edit.html.tmpl

@@ -0,0 +1,316 @@
+<html>
+<head>
+<script src="/hugo/simplemde.js"></script>
+<style type="text/css" media="screen">
+#editor-wrapper { 
+	position: absolute;
+	top: 50px;
+	right: 0;
+	bottom: 150px;
+	left: 40%;
+}
+#draft {
+	position: absolute;
+	top: 50px;
+	right: 60%;
+	bottom: 0;
+	left: 0;
+
+}
+#draft > iframe {
+	height: 100%;
+	width: 100%;
+	border: none;
+}
+a {
+	text-decoration: underline;
+	text-decoration-style: dotted;
+	cursor: pointer;
+}
+</style>
+<link rel="stylesheet" href="/hugo/simplemde.css" />
+<script src="/hugo/vue.js"></script>
+<script src="/hugo/moment.js"></script>
+
+
+<body>
+<div id="container" >
+	<div id="header">
+		<div id="lastSaved">
+			<span v-if="sendQueue.length > 0 || Object.keys(needConfirmation).length > 0">last saved ${ lastSaved.from(now) }, saving</span>
+			<span v-else>saved</span>
+			<span v-if="connectionError">, ${connectionError}</span>
+		</div>
+		<div>
+			<a id="sideview-toggle-media">media</a>
+			<a id="sideview-toggle-draft">draft</a>
+		</div>
+	</div>
+	<div id="editor-wrapper">
+		<textarea id="editor">{{ .LoadContent }}</textarea>
+	</div>
+	<div id="draft"><iframe src="{{ .IframeSource }}">Loading draft...</iframe></div>
+</div>
+<script>
+
+    var iframe = document.querySelector("#draft > iframe");
+
+    document.onclick = function (event) {
+	    var iframe = document.querySelector("#draft > iframe");
+	    switch (event.target.id) {
+	    case "sideview-toggle-media":
+		    iframe.src = "/hugo/media";
+		    break;
+	    case "sideview-toggle-draft":
+		    iframe.src = "{{ .IframeSource }}";
+		    break;
+	    }
+    }
+
+    var uiBindings = {
+	    ltime: {{ .LTime }},
+	    serverLtime: 0,
+	    lastSaved: moment(),
+	    now: moment(),
+	    connectionError: null,
+	    sendQueue: [],
+	    sentRecently: [],
+	    needConfirmation: {},
+    };
+
+    var app = new Vue({
+	    el: "#container",
+	    data: uiBindings,
+	    delimiters: ["${", "}"],
+    });
+
+    function getLtime() {
+	    uiBindings.ltime++
+	    return uiBindings.ltime
+    }
+
+    function observeServer(l, confirmed) {
+	    uiBindings.serverLtime = l;
+	    if (confirmed && confirmed.length > 0) {
+		    confirmed.forEach(function (e) {
+			    delete uiBindings.needConfirmation[e];
+		    })
+	    }
+	    observe(l);
+    }
+
+    function observe(l) {
+	 if (l > uiBindings.ltime) { 
+		 uiBindings.now = moment();
+		 uiBindings.lastSaved = moment();
+		 uiBindings.ltime = l;
+	 }
+    }
+
+    var selectedImage;
+    var editorElem = document.getElementById("editor");
+    var editor = new SimpleMDE({
+	    element: editorElem,
+	    forceSync: true,
+	    insertTexts: {
+		    image: ["{\{% thumb filename=\"", "#url#\" width=\"200\" %}}"]
+	    },
+	    imageURLFn: function () {
+		    return selectedImage;
+	    }
+    });
+
+    window.onmessage = function (evt) {
+	    selectedImage = evt.data;
+    }
+
+
+    // Create WebSocket connection.
+    var socket = connect();
+
+
+    const sawChangesBumpsTo = 10;
+
+    var sentinelSrc = 'about:blank';
+    var oldSrc = '';
+
+    var sawChanges = -1;
+    window.setInterval(function () {
+	    if (sawChanges >= 0) {
+		    sawChanges--;
+		    if (sawChanges == 0) {
+			    if (iframe.contentWindow) {
+				    iframe.contentWindow.location.reload();
+			    }
+		    }
+	    }
+
+	    uiBindings.now = moment();
+	    if (uiBindings.connectionError) {
+		    socket = connect();
+	    } else if (uiBindings.sendQueue.length > 0) {
+		    var ltime = getLtime();
+
+		    // record lowest pending
+		    // ltime at the time this message
+		    // was serialized
+		    var lowestPending = ltime;
+		    for (c in uiBindings.needConfirmation) {
+			    c = parseInt(c, 10);
+			    if (lowestPending === 0 || c < lowestPending) {
+				    lowestPending = c;
+			    }
+		    }
+
+		    var msg = JSON.stringify({
+			    "deltas": uiBindings.sendQueue,
+			    "ltime": ltime,
+			    "lowestPending": lowestPending,
+		    });
+		    uiBindings.sendQueue = [];
+		    uiBindings.needConfirmation[ltime] = msg;
+	    }
+
+	    for (ltime in uiBindings.needConfirmation) {
+		    var msg = uiBindings.needConfirmation[ltime];
+		    socket.send(msg);
+	    }
+    }, 500);
+
+    function connect() {
+	    const socket = new WebSocket((location.protocol == "https:" ? 'wss://' : 'ws://') + location.host + location.pathname);
+
+	    // Listen for messages
+	    socket.addEventListener('message', function (event) {
+		 var message = JSON.parse(event.data);
+		 observeServer(message.ltime, message.confirmed);
+
+		 var deltas = [];
+		 deltas.push.apply(deltas, message.deltas);
+
+		 deltas.forEach(function(aceDelta) {
+			 var cmDelta = aceDeltaToCM(aceDelta)
+
+			 var content = ""
+			 var to = {
+				 line: aceDelta.start.row,
+				 ch: aceDelta.start.column,
+			 }
+
+			 if (aceDelta.action == "insert") {
+				 content = aceDelta.lines.join("\n");
+				 to = null;
+			 }
+
+			 editor.codemirror.doc.replaceRange(content, cmDelta.from, to, "dontreflect");
+			 sawChanges = sawChangesBumpsTo;
+		 })
+	    });
+
+	    socket.addEventListener('open', function () {
+		    uiBindings.connectionError = null;
+	    });
+
+	    socket.addEventListener('close', function () {
+		    if (!uiBindings.connectionError) {
+			    getLtime();
+			    uiBindings.connectionError = "server connection closed, reconnecting...";
+		    }
+	    });
+
+	    socket.addEventListener('error', function (err) {
+		    if (!uiBindings.connectionError) {
+			    uiBindings.connectionError = err;
+		     	    getLtime();
+		    }
+		    console.log(err);
+	    });
+
+
+	    return socket;
+    }
+
+    editor.codemirror.on("change", function (cm, cmDelta) {
+		    if (cmDelta.origin == "dontreflect") {
+			    return;
+		    }
+
+		    var aceDelta = cmDeltaToAce(cmDelta);
+		    console.log(cmDelta, "=>", aceDelta)
+
+		    sawChanges = sawChangesBumpsTo;
+		    uiBindings.sendQueue.push.apply(uiBindings.sendQueue, aceDelta);
+    })
+
+    function cmDeltaToAce(cmDelta) {
+	    var isRemove =  (cmDelta.removed.length > 0 && cmDelta.removed[0].length > 0) || cmDelta.removed.length > 1;
+	    var lines = isRemove ? cmDelta.removed : cmDelta.text;
+	    var aceDelta = {
+		    action: isRemove ? "remove" : "insert",
+		    lines: lines,
+		    start: {
+			    row: cmDelta.from.line,
+			    column: cmDelta.from.ch,
+		    },
+		    end: {
+			    row: cmDelta.from.line + (isRemove ? lines.length - 1 : lines.length - 1 ),
+			    column: lines[lines.length-1].length,
+		    }
+	    };
+
+	    if (aceDelta.start.row == aceDelta.end.row) {
+		    aceDelta.end.column += cmDelta.from.ch;
+	    }
+
+	    if (false && isRemove && aceDelta.start.row == aceDelta.end.row) {
+		    var origStart = aceDelta.start;
+		    aceDelta.start = aceDelta.end;
+		    aceDelta.end = origStart;
+		    aceDelta.start.column += cmDelta.from.ch;
+	    }
+
+	    if (isRemove && ((cmDelta.text.length > 0 && cmDelta.text[0].length > 0) || cmDelta.text.length > 1)) {
+		    cmDelta.removed = [""];
+		    var ret = [aceDelta];
+		    ret.push.apply(ret, cmDeltaToAce(cmDelta));
+		    return ret;
+	    }
+
+	    return [aceDelta];
+    }
+
+    function aceDeltaToCM(aceDelta) {
+
+	    var cmDelta = {
+		    text: [],
+		    removed: [],
+		    from: {
+			    line: aceDelta.start.row,
+			    ch: aceDelta.start.column,
+		    },
+		    to: {
+			    // cm deltas are weird. to refers to the selection end, which 
+			    // with a simple blinking cursor with no selection, is always 
+			    // the same as from
+			    line: aceDelta.start.row,
+			    ch: aceDelta.start.column,
+		    },
+	    }
+
+	    if (aceDelta.action == "remove") {
+		    var origStart = aceDelta.start;
+		    aceDelta.start = aceDelta.end;
+		    aceDelta.end = origStart;
+
+		    cmDelta.removed = aceDelta.lines
+		    cmDelta.text = [""]
+	    } else {
+		    cmDelta.text = aceDelta.lines
+		    cmDelta.removed = [""]
+	    }
+
+	    return cmDelta;
+    }
+</script>
+</body>
+</html>

frontend/templates/upload.html.tmpl

@@ -0,0 +1,70 @@
+<input type="file" style="display: hidden;" id="{{.ElemName}}" />
+	<div id="{{.ElemName}}_dropzone" ondrop="dropHandler(event);" ondragover="draghandler(event);" ondragenter="draghandler(event);" ondragleave="draghandler(event);" style="background-color: rgba(0,0,0,0.5); visibility: hidden; opacity:0; position: fixed; top: 0; bottom: 0; left: 0; right: 0; width: 100%; height: 100%; ; transition: visibility 175ms, opacity 175ms; z-index: 9999999;"></div>
+	<script>
+document.addEventListener("DOMContentLoaded", function () {
+	var fileInput = document.getElementById('{{.ElemName}}');
+	var dropzone = document.getElementById('{{.ElemName}}_dropzone');
+
+	fileInput.onchange = function () {
+		var formData = new FormData();
+		fileInput.files.forEach(function (file) {
+			formData.append(file.name, file);
+		});
+		upload(formData);
+	}
+
+	var lastTarget = null;
+
+	window.addEventListener("dragenter", function(e)
+	{
+		lastTarget = e.target; // cache the last target here
+		// unhide our dropzone overlay
+		dropzone.style.visibility = "";
+		dropzone.style.opacity = 1;
+	});
+
+	window.addEventListener("dragleave", function(e)
+	{
+		// this is the magic part. when leaving the window,
+		// e.target happens to be exactly what we want: what we cached
+		// at the start, the dropzone we dragged into.
+		// so..if dragleave target matches our cache, we hide the dropzone.
+		if(e.target === lastTarget)
+		{
+			dropzone.style.visibility = "hidden";
+			dropzone.style.opacity = 0;
+		}
+	});
+
+});
+
+	function draghandler(evt) {
+		evt.preventDefault();
+	}
+
+	function dropHandler(evt) {
+		evt.preventDefault();
+
+		var files = evt.dataTransfer.files;
+		var formData = new FormData();
+
+		for (var i = 0; i < files.length; i++) {
+			formData.append(files[i].name, files[i]);
+		}
+
+		upload(formData);
+		return false;
+	}
+
+	function upload(formData) {
+		var xhr = new XMLHttpRequest();
+		xhr.onreadystatechange = function(e) {
+			if ( 4 == this.readyState ) {
+				window.location.reload(true);
+			}
+		}
+		xhr.open('POST', '/hugo/upload');
+		xhr.send(formData);
+	}
+
+</script>

go.mod

@@ -0,0 +1,142 @@
+module git.stephensearles.com/stephen/caddy-hugo2
+
+go 1.18
+
+require (
+	git.stephensearles.com/stephen/acedoc v0.0.0-20170928122432-96da2793a59d
+	git.stephensearles.com/stephen/idleshut v0.0.0-20180107224249-cde7779f51c8
+	github.com/PuerkitoBio/goquery v1.5.0
+	github.com/caddyserver/caddy/v2 v2.1.1
+	github.com/caddyserver/xcaddy v0.3.0
+	github.com/gohugoio/hugo v0.74.4-0.20200822075643-d39636a5fc6b
+	github.com/gorilla/websocket v1.4.1
+	github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646
+	github.com/peterbourgon/diskv v2.0.1+incompatible
+	github.com/spf13/afero v1.2.2
+	github.com/spf13/viper v1.6.1
+	github.com/tajtiattila/metadata v0.0.0-20180130123038-1ef25f4c37ea
+	go.uber.org/zap v1.15.0
+)
+
+require (
+	cloud.google.com/go v0.54.0 // indirect
+	github.com/AndreasBriese/bbloom v0.0.0-20190306092124-e2d15f34fcf9 // indirect
+	github.com/BurntSushi/locker v0.0.0-20171006230638-a6e239ea1c69 // indirect
+	github.com/BurntSushi/toml v0.3.1 // indirect
+	github.com/DataDog/zstd v1.4.1 // indirect
+	github.com/Masterminds/goutils v1.1.0 // indirect
+	github.com/Masterminds/semver/v3 v3.1.1 // indirect
+	github.com/Masterminds/sprig/v3 v3.1.0 // indirect
+	github.com/PuerkitoBio/purell v1.1.1 // indirect
+	github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578 // indirect
+	github.com/alecthomas/chroma v0.8.0 // indirect
+	github.com/andybalholm/cascadia v1.0.0 // indirect
+	github.com/antlr/antlr4 v0.0.0-20200503195918-621b933c7a7f // indirect
+	github.com/armon/go-radix v1.0.0 // indirect
+	github.com/bep/debounce v1.2.0 // indirect
+	github.com/bep/gitmap v1.1.2 // indirect
+	github.com/bep/golibsass v0.6.0 // indirect
+	github.com/bep/tmc v0.5.1 // indirect
+	github.com/caddyserver/certmagic v0.11.2 // indirect
+	github.com/cenkalti/backoff/v4 v4.0.0 // indirect
+	github.com/cespare/xxhash v1.1.0 // indirect
+	github.com/cheekybits/genny v1.0.0 // indirect
+	github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e // indirect
+	github.com/cpuguy83/go-md2man/v2 v2.0.0 // indirect
+	github.com/danwakefield/fnmatch v0.0.0-20160403171240-cbb64ac3d964 // indirect
+	github.com/dgraph-io/badger v1.5.3 // indirect
+	github.com/dgraph-io/badger/v2 v2.0.1-rc1.0.20200413122845-09dd2e1a4195 // indirect
+	github.com/dgraph-io/ristretto v0.0.2-0.20200115201040-8f368f2f2ab3 // indirect
+	github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 // indirect
+	github.com/disintegration/gift v1.2.1 // indirect
+	github.com/dlclark/regexp2 v1.2.0 // indirect
+	github.com/dustin/go-humanize v1.0.1-0.20200219035652-afde56e7acac // indirect
+	github.com/evanw/esbuild v0.6.5 // indirect
+	github.com/fsnotify/fsnotify v1.4.9 // indirect
+	github.com/getkin/kin-openapi v0.14.0 // indirect
+	github.com/ghodss/yaml v1.0.0 // indirect
+	github.com/go-acme/lego/v3 v3.7.0 // indirect
+	github.com/go-sql-driver/mysql v1.5.0 // indirect
+	github.com/gobuffalo/envy v1.7.0 // indirect
+	github.com/gobwas/glob v0.2.3 // indirect
+	github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e // indirect
+	github.com/golang/protobuf v1.4.2 // indirect
+	github.com/golang/snappy v0.0.1 // indirect
+	github.com/google/btree v1.0.0 // indirect
+	github.com/google/cel-go v0.5.1 // indirect
+	github.com/google/go-cmp v0.5.0 // indirect
+	github.com/google/uuid v1.1.1 // indirect
+	github.com/googleapis/gax-go/v2 v2.0.5 // indirect
+	github.com/hashicorp/hcl v1.0.0 // indirect
+	github.com/huandu/xstrings v1.3.1 // indirect
+	github.com/imdario/mergo v0.3.8 // indirect
+	github.com/jdkato/prose v1.1.1 // indirect
+	github.com/joho/godotenv v1.3.0 // indirect
+	github.com/juju/ansiterm v0.0.0-20180109212912-720a0952cc2a // indirect
+	github.com/klauspost/cpuid v1.3.0 // indirect
+	github.com/kyokomi/emoji v2.2.1+incompatible // indirect
+	github.com/libdns/libdns v0.0.0-20200501023120-186724ffc821 // indirect
+	github.com/lucas-clemente/quic-go v0.18.0 // indirect
+	github.com/lunixbochs/vtclean v1.0.0 // indirect
+	github.com/magiconair/properties v1.8.1 // indirect
+	github.com/manifoldco/promptui v0.3.1 // indirect
+	github.com/markbates/inflect v1.0.0 // indirect
+	github.com/marten-seemann/qpack v0.2.0 // indirect
+	github.com/marten-seemann/qtls v0.10.0 // indirect
+	github.com/marten-seemann/qtls-go1-15 v0.1.0 // indirect
+	github.com/mattn/go-colorable v0.1.6 // indirect
+	github.com/mattn/go-isatty v0.0.12 // indirect
+	github.com/mattn/go-runewidth v0.0.7 // indirect
+	github.com/miekg/dns v1.1.30 // indirect
+	github.com/miekg/mmark v1.3.6 // indirect
+	github.com/mitchellh/copystructure v1.0.0 // indirect
+	github.com/mitchellh/hashstructure v1.0.0 // indirect
+	github.com/mitchellh/mapstructure v1.1.2 // indirect
+	github.com/mitchellh/reflectwalk v1.0.0 // indirect
+	github.com/muesli/smartcrop v0.3.0 // indirect
+	github.com/nicksnyder/go-i18n v1.10.0 // indirect
+	github.com/niklasfasching/go-org v1.3.1 // indirect
+	github.com/olekukonko/tablewriter v0.0.4 // indirect
+	github.com/pelletier/go-toml v1.6.0 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/rogpeppe/go-internal v1.5.1 // indirect
+	github.com/russross/blackfriday v1.5.3-0.20200218234912-41c5fccfd6f6 // indirect
+	github.com/russross/blackfriday/v2 v2.0.1 // indirect
+	github.com/rwcarlsen/goexif v0.0.0-20190401172101-9e8deecbddbd // indirect
+	github.com/samfoo/ansi v0.0.0-20160124022901-b6bd2ded7189 // indirect
+	github.com/sanity-io/litter v1.2.0 // indirect
+	github.com/shurcooL/sanitized_anchor_name v1.0.0 // indirect
+	github.com/smallstep/certificates v0.15.0-rc.1.0.20200506212953-e855707dc274 // indirect
+	github.com/smallstep/cli v0.14.4 // indirect
+	github.com/smallstep/nosql v0.3.0 // indirect
+	github.com/smallstep/truststore v0.9.5 // indirect
+	github.com/spf13/cast v1.3.1 // indirect
+	github.com/spf13/jwalterweatherman v1.1.0 // indirect
+	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/subosito/gotenv v1.2.0 // indirect
+	github.com/tdewolff/minify/v2 v2.6.2 // indirect
+	github.com/tdewolff/parse/v2 v2.4.2 // indirect
+	github.com/urfave/cli v1.22.2 // indirect
+	github.com/yuin/goldmark v1.1.32 // indirect
+	github.com/yuin/goldmark-highlighting v0.0.0-20200307114337-60d527fdb691 // indirect
+	go.etcd.io/bbolt v1.3.2 // indirect
+	go.opencensus.io v0.22.3 // indirect
+	go.uber.org/atomic v1.6.0 // indirect
+	go.uber.org/multierr v1.5.0 // indirect
+	golang.org/x/crypto v0.0.0-20200728195943-123391ffb6de // indirect
+	golang.org/x/image v0.0.0-20191214001246-9130b4cfad52 // indirect
+	golang.org/x/net v0.0.0-20200707034311-ab3426394381 // indirect
+	golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d // indirect
+	golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e // indirect
+	golang.org/x/sys v0.0.0-20200519105757-fe76b779f299 // indirect
+	golang.org/x/text v0.3.2 // indirect
+	google.golang.org/api v0.20.0 // indirect
+	google.golang.org/appengine v1.6.5 // indirect
+	google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013 // indirect
+	google.golang.org/grpc v1.27.1 // indirect
+	google.golang.org/protobuf v1.25.0 // indirect
+	gopkg.in/ini.v1 v1.51.1 // indirect
+	gopkg.in/square/go-jose.v2 v2.4.0 // indirect
+	gopkg.in/yaml.v2 v2.3.0 // indirect
+	howett.net/plist v0.0.0-20200419221736-3b63eb3a43b5 // indirect
+)

helpers_test.go

@@ -0,0 +1,96 @@
+package caddyhugo
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"sync"
+	"testing"
+
+	"git.stephensearles.com/stephen/acedoc"
+)
+
+type World struct {
+	CH         *CaddyHugo
+	BlogFolder string
+}
+
+func (w *World) Clean() {
+	if w.BlogFolder != "" {
+		os.RemoveAll(w.BlogFolder)
+	}
+}
+
+func NewWorld(t *testing.T) *World {
+	dir, err := ioutil.TempDir("", "caddy-hugo2-test-")
+	if err != nil {
+		t.Fatalf("error initializing test environment: %v", err)
+	}
+
+	w := &World{BlogFolder: dir}
+
+	cmd := exec.Command("hugo", "new", "site", dir)
+	cmd.Dir = dir
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("error initializing test site: %v\n\n%v", err, string(out))
+	}
+
+	w.CH = &CaddyHugo{}
+	w.CH.Setup(dir)
+
+	return w
+}
+
+type WebsocketTester struct {
+	receivedPointer int
+	received        [][]byte
+	wroteMessages   []Message
+	wroteDeltas     []acedoc.Delta
+	mtx             sync.Mutex
+}
+
+// ReadJSON reads the next pending message from the "client" into v
+func (ws *WebsocketTester) ReadJSON(v interface{}) error {
+	ws.mtx.Lock()
+	defer ws.mtx.Unlock()
+
+	if len(ws.received) <= ws.receivedPointer {
+		return nil
+	}
+
+	err := json.Unmarshal(ws.received[ws.receivedPointer], v)
+	ws.receivedPointer++
+	return err
+}
+
+// WriteJSON "sends" a message, v, to the "client"
+func (ws *WebsocketTester) WriteJSON(v interface{}) error {
+	ws.mtx.Lock()
+	defer ws.mtx.Unlock()
+
+	m, ok := v.(Message)
+	if !ok {
+		panic("wrong type written to WebsocketTester")
+	}
+
+	ws.wroteMessages = append(ws.wroteMessages, m)
+	ws.wroteDeltas = append(ws.wroteDeltas, m.Deltas...)
+
+	return nil
+}
+
+// ReceiveJSON queues a message to be sent to the client
+func (ws *WebsocketTester) ReceiveJSON(v interface{}) error {
+	ws.mtx.Lock()
+	defer ws.mtx.Unlock()
+
+	out, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+
+	ws.received = append(ws.received, out)
+	return nil
+}

http.go

@@ -0,0 +1,326 @@
+package caddyhugo
+
+import (
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+
+	"git.stephensearles.com/stephen/caddy-hugo2/assets"
+	"github.com/caddyserver/caddy/v2/modules/caddyhttp"
+	"github.com/spf13/afero"
+)
+
+func (ch *CaddyHugo) ServeHTTP(w http.ResponseWriter, r *http.Request, next caddyhttp.Handler) error {
+	if !ch.Match(r) {
+		p := path.Join(ch.Dir, "public", r.URL.Path)
+		http.ServeFile(w, r, p)
+		return nil
+	}
+
+	if ch.Comments != nil && strings.HasSuffix(r.URL.Path, "/comments") {
+		docName := docNameFromCommentRequest(r)
+		err := ch.Comments.ServeComments(docName, w, r)
+		if err != nil {
+			return fmt.Errorf("couldn't load comments:", err)
+		}
+
+		return nil
+	}
+
+	if r.URL.Path == "/login" {
+		return ch.commentsLogin(r, w)
+	}
+
+	if strings.HasPrefix(r.URL.Path, "/hugo/publish") {
+		err := ch.Publish()
+		if err != nil {
+			return err
+		}
+
+		http.Redirect(w, r, "/", http.StatusFound)
+		return nil
+	}
+	if strings.HasPrefix(r.URL.Path, "/hugo/simplemde.css") {
+		w.Write(assets.MustAsset("simplemde/dist/simplemde.min.css"))
+		return nil
+	}
+	if strings.HasPrefix(r.URL.Path, "/hugo/simplemde.js") {
+		w.Write(assets.MustAsset("simplemde/debug/simplemde.js"))
+		return nil
+	}
+	if strings.HasPrefix(r.URL.Path, "/hugo/vue.js") {
+		w.Write(assets.MustAsset("js/vue.js"))
+		return nil
+	}
+	if strings.HasPrefix(r.URL.Path, "/hugo/moment.js") {
+		w.Write(assets.MustAsset("js/moment.js"))
+		return nil
+	}
+	if strings.HasPrefix(r.URL.Path, "/hugo/font-awesome.css") {
+		w.Write(assets.MustAsset("css/font-awesome.min.css"))
+		return nil
+	}
+	if strings.HasPrefix(r.URL.Path, "/hugo/admin") {
+		return ch.Admin().ServeHTTP(w, r)
+	}
+	if strings.HasPrefix(r.URL.Path, "/hugo/author") {
+		return ch.AuthorHome().ServeHTTP(w, r)
+	}
+	if strings.HasPrefix(r.URL.Path, "/hugo/edit/") {
+		return ch.Edit().ServeHTTP(w, r)
+	}
+	if strings.HasPrefix(r.URL.Path, "/hugo/draft/") {
+		return ch.serveDraft(w, r)
+	}
+	if strings.HasPrefix(r.URL.Path, "/hugo/media") {
+		return ch.serveMediaPage(w, r)
+	}
+	if strings.HasPrefix(r.URL.Path, "/hugo/upload") {
+		return ch.uploadMedia(w, r)
+	}
+	if strings.HasPrefix(r.URL.Path, "/media/") {
+		return ch.serveMedia(w, r)
+	}
+	if strings.HasPrefix(r.URL.Path, "/hugo/fs/") {
+		printTree(afero.NewOsFs(), w, ch.Dir)
+		return nil
+	}
+
+	return next.ServeHTTP(w, r)
+}
+
+func (ch *CaddyHugo) ServeNewContent(w http.ResponseWriter, r *http.Request) error {
+	name := r.FormValue("name")
+	ctype := r.FormValue("type")
+
+	filename, err := ch.NewContent(name, ctype)
+	if err != nil {
+		fmt.Println("error creating new content:", err)
+		return err
+	}
+
+	// serve redirect
+	http.Redirect(w, r, filepath.Join("/hugo/edit/", "content", filename), http.StatusFound)
+	return nil
+}
+
+func (ch *CaddyHugo) Auth(r *http.Request) bool {
+	// this is handled upstream by the caddy configuration
+	return true
+}
+
+func (ch *CaddyHugo) Match(r *http.Request) bool {
+	if strings.HasPrefix(r.URL.Path, "/media/") {
+		return true
+	}
+
+	if strings.HasSuffix(r.URL.Path, "/comments") {
+		return true
+	}
+
+	if r.URL.Path == "/login" {
+		return true
+	}
+
+	if r.URL.Path == "/hugo" {
+		return true
+	}
+
+	return strings.HasPrefix(r.URL.Path, "/hugo/")
+}
+
+func (ch *CaddyHugo) Admin() caddyhttp.Handler {
+	return caddyhttp.HandlerFunc(func(w http.ResponseWriter, r *http.Request) error {
+		err := ch.adminTmpl.Execute(w, ch.TmplData(r, nil))
+		if err != nil {
+			fmt.Println(err)
+			return err
+		}
+
+		return nil
+
+	})
+}
+
+func (ch *CaddyHugo) AuthorHome() caddyhttp.Handler {
+	return caddyhttp.HandlerFunc(func(w http.ResponseWriter, r *http.Request) error {
+		td := ch.TmplData(r, nil)
+		err := ch.authorTmpl.Execute(w, td)
+		if err != nil {
+			fmt.Println(err)
+			return err
+		}
+
+		return nil
+	})
+}
+
+func (ch *CaddyHugo) Edit() caddyhttp.Handler {
+	return caddyhttp.HandlerFunc(func(w http.ResponseWriter, r *http.Request) error {
+		if r.URL.Path == "/hugo/edit/new" {
+			return ch.ServeNewContent(w, r)
+		}
+
+		if r.Header.Get("Upgrade") == "websocket" {
+			return ch.DeltaWebsocket(w, r)
+		}
+
+		doc, err := ch.editSession(docNameFromEditRequest(r))
+		if err != nil {
+			fmt.Println(err)
+			http.Error(w, err.Error(), http.StatusNotFound)
+			return err
+		}
+
+		err = ch.editTmpl.Execute(w, ch.TmplData(r, doc))
+		if err != nil {
+			fmt.Println(err)
+			return err
+		}
+
+		return nil
+	})
+}
+
+func (ch *CaddyHugo) serveDraft(w http.ResponseWriter, r *http.Request) error {
+	pathSegments := strings.SplitN(r.URL.Path, "/", 5)
+	if len(pathSegments) < 4 {
+		return errors.New("not found")
+	}
+
+	encoded := pathSegments[3]
+
+	nameBytes, err := base64.RawURLEncoding.DecodeString(encoded)
+	if err != nil {
+		return errors.New("not found")
+	}
+
+	name := string(nameBytes)
+
+	ch.mtx.Lock()
+	defer ch.mtx.Unlock()
+
+	docref, ok := ch.docs[ch.docFilename(name)]
+	if !ok {
+		return fmt.Errorf("draft not found")
+	}
+
+	r.URL.Path = strings.ToLower(r.URL.Path)
+
+	prefix := "/hugo/draft/" + encoded
+	r.URL.Path = path.Join("public", r.URL.Path[len(prefix):])
+
+	page := ch.HugoSites.GetContentPage(ch.docFilename(name))
+	if page == nil {
+		fmt.Fprintf(w, "can't find %q to display a draft", name)
+		return fmt.Errorf("draft not found")
+	}
+
+	r.URL.Path = page.RelPermalink()
+	http.FileServer(aferoHTTP{afero.NewBasePathFs(docref.tmpfs, path.Join(ch.Dir, "public"))}).ServeHTTP(w, r)
+
+	return nil
+}
+
+func printTree(fs afero.Fs, w io.Writer, dir string) {
+	const (
+		Line  = "  │ "
+		Tab   = "    "
+		Elbow = "  └─"
+		Tee   = "  ├─"
+	)
+
+	wd, _ := os.Getwd()
+	fmt.Fprintln(w, wd)
+
+	if dir == "" {
+		dir = "/"
+	}
+
+	openDirs := map[string]bool{}
+	lastFiles := map[string]string{}
+
+	afero.Walk(fs, dir, filepath.WalkFunc(func(p string, info os.FileInfo, err error) error {
+		if strings.HasPrefix(p, "./") {
+			p = p[2:]
+		}
+
+		openDirs[filepath.Dir(p)] = true
+		lastFiles[filepath.Dir(p)] = filepath.Base(p)
+		return nil
+	}))
+
+	afero.Walk(fs, dir, filepath.WalkFunc(func(p string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if strings.HasPrefix(p, "./") {
+			p = p[2:]
+		}
+
+		if filepath.Base(p)[0] == '.' && info.IsDir() {
+			return filepath.SkipDir
+		}
+
+		entry := Tee
+
+		if lastFiles[filepath.Dir(p)] == filepath.Base(p) {
+			openDirs[filepath.Dir(p)] = false
+			entry = Elbow
+		}
+
+		indent := ""
+		dirs := strings.Split(p, string(filepath.Separator))
+		dirs = dirs[:len(dirs)-1]
+		for i := range dirs {
+			if openDirs[filepath.Join(dirs[:i]...)] {
+				indent += Line
+			} else {
+				indent += Tab
+			}
+		}
+
+		fmt.Fprintf(w, "%s%s %s (%s)\n", indent, entry, filepath.Base(p), p)
+		return nil
+	}))
+}
+
+type aferoHTTP struct {
+	afero.Fs
+}
+
+func (a aferoHTTP) Open(name string) (http.File, error) {
+	af, err := a.Fs.Open(name)
+	if os.IsExist(err) {
+		err = os.ErrExist
+	}
+	if os.IsNotExist(err) {
+		err = os.ErrNotExist
+	}
+	return af, err
+}
+
+func (ch *CaddyHugo) commentsLogin(r *http.Request, w http.ResponseWriter) error {
+	if ch.Comments == nil {
+		return nil
+	}
+
+	_, ok := ch.Comments.User(r)
+	if !ok {
+		w.Header().Set("WWW-Authenticate", `Basic realm="Log in with your name and the password. Ask Dan or Stephen for the password."`)
+		w.WriteHeader(401)
+		fmt.Fprintf(w, "<html><body>Log in with your name and the password. Ask Dan or Stephen for the password. <a href=%q>go back</a></body></html>", r.Referer())
+		return nil
+	}
+
+	http.Redirect(w, r, r.Referer(), http.StatusFound)
+
+	return nil
+}

hugo.go

@@ -0,0 +1,138 @@
+package caddyhugo
+
+import (
+	"fmt"
+	"os"
+	"path"
+	"path/filepath"
+	"time"
+
+	"github.com/gohugoio/hugo/deps"
+	"github.com/gohugoio/hugo/hugofs"
+	"github.com/gohugoio/hugo/hugolib"
+	"github.com/spf13/afero"
+	"github.com/spf13/viper"
+
+	themeadditions "git.stephensearles.com/stephen/caddy-hugo2/theme-additions"
+	"git.stephensearles.com/stephen/idleshut"
+)
+
+const (
+	IdleWebsocketTimeout = 10 * time.Minute
+	WebsocketFileTicker  = 1 * time.Second
+)
+
+// Publish really renders new content into the public directory
+func (ch *CaddyHugo) Publish() error {
+	err := ch.persistAllEdits()
+	if err != nil {
+		return err
+	}
+
+	err = buildSite(ch.HugoSites)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func buildSite(sites *hugolib.HugoSites) error {
+	err := sites.Build(hugolib.BuildCfg{ResetState: true})
+	if err != nil {
+		return fmt.Errorf("caddy-hugo: building site: %v", err)
+	}
+
+	return err
+}
+
+func writeThemeFiles(dir string) error {
+	for _, asset := range themeadditions.AssetNames() {
+		err := os.MkdirAll(path.Join(dir, filepath.Dir(asset)), 0755)
+		if err != nil {
+			return err
+		}
+		f, err := os.Create(path.Join(dir, asset))
+		if err != nil {
+			return err
+		}
+		b, err := themeadditions.Asset(asset)
+		if err != nil {
+			return err
+		}
+
+		_, err = f.Write(b)
+		if err != nil {
+			return err
+		}
+
+		err = f.Close()
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (ch *CaddyHugo) configWithFs(fs afero.Fs) (*hugolib.HugoSites, *deps.DepsCfg, error) {
+	var err error
+
+	hfs := hugofs.NewFrom(fs, &viper.Viper{})
+	cfg := &deps.DepsCfg{Fs: hfs}
+
+	cfgPath := path.Join(ch.Dir, "config.toml")
+	cfg.Cfg, _, err = hugolib.LoadConfig(hugolib.ConfigSourceDescriptor{Fs: fs, Path: cfgPath})
+	if err != nil {
+		return nil, cfg, fmt.Errorf("caddy-hugo: loading site configuration: %v", err)
+	}
+	cfg.Cfg.Set("workingDir", ch.Dir)
+
+	sites, err := hugolib.NewHugoSites(*cfg)
+	if err != nil {
+		return nil, cfg, fmt.Errorf("caddy-hugo: initializing site: %v", err)
+	}
+
+	err = buildSite(sites)
+
+	return sites, cfg, err
+}
+
+func HugoInternalProcessConfig(ch *CaddyHugo, es *editSession, touchFn func()) (idleshut.Config, error) {
+	hugoSites, _, err := ch.configWithFs(es.tmpfs)
+	if err != nil {
+		return idleshut.Config{}, fmt.Errorf("caddy-hugo: loading site configuration: %v", err)
+	}
+
+	return idleshut.Config{
+		TickDuration: WebsocketFileTicker,
+		MaxIdleTicks: uint(IdleWebsocketTimeout/WebsocketFileTicker) + 1,
+		Stop: func() error {
+			ch.persistEditsForSession(es)
+
+			es.doc.Close()
+
+			ch.mtx.Lock()
+			defer ch.mtx.Unlock()
+			delete(ch.docs, es.filename)
+
+			return nil
+		},
+		TickError: func(err error) {
+			fmt.Println("error processing draft:", err)
+		},
+		Tick: func() error {
+			err := afero.WriteFile(es.tmpfs, es.filename, []byte(es.doc.Contents()), 0644)
+			if err != nil {
+				return err
+			}
+
+			err = buildSite(hugoSites)
+			if err != nil {
+				return err
+			}
+
+			return nil
+		},
+	}, nil
+}

makefile

@@ -0,0 +1,8 @@
+.PHONY: run
+run: CADDY_DEBUG=1
+run:
+	xcaddy build --with git.stephensearles.com/stephen/caddy-hugo2@latest=./ && cd testdir && ../caddy run --config Caddyfile
+
+.PHONY: build
+build:
+	xcaddy build --with github.com/caddy-dns/digitalocean --with git.stephensearles.com/stephen/caddy-hugo2@latest=./

media.go

@@ -1,246 +1,96 @@
 package caddyhugo
 
 import (
+	"bytes"
 	"fmt"
-	"image"
-	_ "image/gif"
-	"image/jpeg"
-	_ "image/png"
 	"io"
 	"net/http"
-	"os"
+	"net/url"
 	"path"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
 
-	"github.com/nfnt/resize"
+	"github.com/PuerkitoBio/goquery"
+	"github.com/gohugoio/hugo/resources/page"
+
+	"git.stephensearles.com/stephen/caddy-hugo2/media"
 )
 
-type MediaSource struct {
-	StorageDir string
-	ThumbDir   string
-}
+func (ch *CaddyHugo) ReferencedMedia() map[string]map[page.Page]struct{} {
+	found := map[string]map[page.Page]struct{}{}
 
-func (ms *MediaSource) LocationOrig(m Media) string {
-	return path.Join(ms.StorageDir, m.Name)
-}
-
-func (ms *MediaSource) ThumbPath(m Media, size image.Rectangle) string {
-	w := size.Dx()
-	h := size.Dy()
-
-	var ws, hs string
-
-	if w != 0 {
-		ws = fmt.Sprint(w)
-	}
-	if h != 0 {
-		hs = fmt.Sprint(h)
-	}
-
-	thumbSlug := filepath.Join(fmt.Sprintf("%sx%s", ws, hs), m.Name)
-	return path.Join("/media", thumbSlug)
-}
-
-func (ms *MediaSource) ThumbFilename(m Media, size image.Rectangle) string {
-	return filepath.Join(ms.ThumbDir, ms.ThumbPath(m, size))
-}
-
-func (ms *MediaSource) receiveNewMedia(name string, r io.Reader) error {
-	dest := path.Join(ms.StorageDir, name)
-	f, err := os.OpenFile(dest, os.O_WRONLY|os.O_CREATE, 0644)
+	for _, pg := range ch.HugoSites.Pages() {
+		renderOutput, err := pg.Render()
 		if err != nil {
-		return err
+			continue
 		}
 
-	_, err = io.Copy(f, r)
+		r := bytes.NewBufferString(string(renderOutput))
+		doc, err := goquery.NewDocumentFromReader(r)
 		if err != nil {
-		return err
+			continue
 		}
-
-	return f.Close()
-}
-
-type Media struct {
-	Type string
-	Name string
-	Size image.Rectangle
-}
-
-func (ms *MediaSource) Size(name string) (image.Rectangle, error) {
-	f, err := os.Open(name)
-	if err != nil {
-		return image.ZR, err
+		doc.Find("img,video").Map(func(i int, s *goquery.Selection) string {
+			u, ok := s.Attr("src")
+			if ok {
+				u = path.Base(u)
+				if ud, err := url.QueryUnescape(u); err == nil {
+					u = ud
 				}
-	defer f.Close()
-
-	cfg, _, err := image.DecodeConfig(f)
-	if err != nil {
-		return image.ZR, err
+				if m := found[u]; m == nil {
+					found[u] = make(map[page.Page]struct{})
 				}
-
-	width := cfg.Width
-	height := cfg.Height
-
-	return image.Rect(0, 0, width, height), nil
-}
-
-func (ms *MediaSource) ThumbMax(m Media, maxDim int) (string, image.Rectangle, error) {
-	f, err := os.Open(ms.LocationOrig(m))
-	if err != nil {
-		return "", image.ZR, err
+				found[u][pg] = struct{}{}
 			}
-	defer f.Close()
-
-	cfg, _, err := image.DecodeConfig(f)
-	if err != nil {
-		return "", image.ZR, err
-	}
-
-	width := cfg.Width
-	height := cfg.Height
-
-	if width > height {
-		height = height * maxDim / width
-		width = maxDim
-	} else {
-		width = width * maxDim / height
-		height = maxDim
-	}
-
-	size := image.Rect(0, 0, width, height)
-	if ms.HasThumb(m, size) {
-		return ms.ThumbPath(m, size), size, nil
-	}
-
-	_, err = f.Seek(0, io.SeekStart)
-	if err != nil {
-		return "", image.ZR, err
-	}
-
-	img, _, err := image.Decode(f)
-	if err != nil {
-		return "", image.ZR, err
-	}
-
-	src, err := ms.ThumbImage(img, m, size)
-	return src, size, err
-}
-
-func (ms *MediaSource) HasThumb(m Media, size image.Rectangle) bool {
-	_, err := os.Stat(ms.ThumbFilename(m, size))
-	return err == nil
-}
-
-func (ms *MediaSource) ByName(name string) *Media {
-	size, _ := ms.Size(path.Join(ms.StorageDir, name))
-	return &Media{
-		Type: "image",
-		Name: name,
-		Size: size,
-	}
-}
-
-func (ms *MediaSource) Thumb(m Media, size image.Rectangle) (string, error) {
-	if ms.HasThumb(m, size) {
-		return ms.ThumbPath(m, size), nil
-	}
-
-	f, err := os.Open(ms.LocationOrig(m))
-	if err != nil {
-		return "", err
-	}
-	defer f.Close()
-
-	img, _, err := image.Decode(f)
-	if err != nil {
-		return "", err
-	}
-
-	return ms.ThumbImage(img, m, size)
-}
-
-func (ms *MediaSource) ThumbImage(img image.Image, m Media, size image.Rectangle) (string, error) {
-
-	thumbLoc := ms.ThumbFilename(m, size)
-	os.MkdirAll(path.Dir(thumbLoc), 0755)
-	fthumb, err := os.OpenFile(thumbLoc, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0655)
-	if err != nil {
-		return "", err
-	}
-
-	img = resize.Resize(uint(size.Dx()), uint(size.Dy()), img, resize.Bilinear)
-
-	err = jpeg.Encode(fthumb, img, nil)
-	if err != nil {
-		return "", err
-	}
-
-	err = fthumb.Close()
-	if err != nil {
-		return "", err
-	}
-
-	return ms.ThumbPath(m, size), nil
-}
-
-func (ms *MediaSource) Walk() ([]*Media, error) {
-	var media []*Media
-
-	err := filepath.Walk(ms.StorageDir, func(name string, fi os.FileInfo, err error) error {
-		if err != nil {
-			return err
-		}
-		if fi.IsDir() {
-			return nil
-		}
-		media = append(media, ms.ByName(path.Base(name)))
-		return nil
+			return ""
 		})
 
-	return media, err
+	}
+
+	return found
 }
 
-func (ch *CaddyHugo) uploadMedia(w http.ResponseWriter, r *http.Request) (int, error) {
+func (ch *CaddyHugo) uploadMedia(w http.ResponseWriter, r *http.Request) error {
 	if ch.Media == nil {
 		http.NotFound(w, r)
-		return 404, nil
+		return nil
 	}
 
 	mr, err := r.MultipartReader()
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest)
-		return 400, nil
+		return nil
 	}
 
 	for {
 		part, err := mr.NextPart()
+		if err == io.EOF {
+			break
+		}
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusBadRequest)
-			return 400, nil
+			return err
 		}
 
 		name := part.FileName()
 		if name != "" {
-			err = ch.Media.receiveNewMedia(name, part)
+			err = ch.Media.ReceiveNewMedia(name, part)
 			if err != nil {
 				http.Error(w, err.Error(), http.StatusInternalServerError)
-				return 500, nil
+				return nil
 			}
 		}
 	}
 
-	return 200, nil
+	return nil
 }
 
-func (ch *CaddyHugo) serveMediaPage(w http.ResponseWriter, r *http.Request) (int, error) {
+func (ch *CaddyHugo) serveMediaPage(w http.ResponseWriter, r *http.Request) error {
 	if ch.Media == nil {
 		http.NotFound(w, r)
-		return 404, nil
+		return nil
 	}
 
+	referenced := ch.ReferencedMedia()
+
 	io.WriteString(w, `<html>
 	<head><style>
 	iframe { height: 100%; }
@@ -266,20 +116,34 @@ func (ch *CaddyHugo) serveMediaPage(w http.ResponseWriter, r *http.Request) (int
 	<div style="display: inline-block; width: 100%; height: 10vh;"></div>
 	`)
 	if ch.Media != nil {
-		media, err := ch.Media.Walk()
+		mm, err := ch.Media.Walk()
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return 500, nil
+			return err
 		}
 
-		for _, m := range media {
+		for _, m := range media.Set(mm).ByDate() {
 
-			src, size, err := ch.Media.ThumbMax(*m, 100)
+			size, err := ch.Media.ThumbMax(*m, 100)
 			if err != nil {
 				fmt.Fprintf(w, `<div class="img">error rendering %q: %v</div>`, m.Name, err)
 				continue
 			}
-			fmt.Fprintf(w, `<div class="img"><img width=%d height=%d src=%q data-filename=%q /><br /><input type="text" readonly value=%q /><span class="copy">&#x1F4CB;</span></div>`, size.Dx(), size.Dy(), src, m.Name, src)
+
+			refs := len(referenced[m.Name])
+			plural := "s"
+			if refs == 1 {
+				plural = ""
+			}
+			refLine := fmt.Sprintf("included on %d page%s", refs, plural)
+
+			switch m.Type {
+			case media.TypeImage:
+				fmt.Fprintf(w, `<div class="img"><img width=%d height=%d src=%q data-filename=%q /><br /><input type="text" readonly value=%q /><span class="copy">&#x1F4CB;</span><br />%s</div>`, size.Dx(), size.Dy(), m.ThumbPath(size), m.Name, m.ThumbPath(size), refLine)
+			case media.TypeVideo:
+				// TODO: onmouseover sucks for mobile
+				fmt.Fprintf(w, `<div class="img"><video width=%d height=%d src=%q data-filename=%q onmouseover="this.play()" onmouseout="this.pause();this.currentTime=0;"></video><br /><input type="text" readonly value=%q /><span class="copy">&#x1F4CB;</span><br />%s</div>`, size.Dx(), size.Dy(), m.ThumbPath(size), m.Name, m.ThumbPath(size), refLine)
+			}
 		}
 	}
 	io.WriteString(w, `<script>
@@ -291,7 +155,7 @@ func (ch *CaddyHugo) serveMediaPage(w http.ResponseWriter, r *http.Request) (int
 			evt.target.previousSibling.select();
 			document.execCommand("copy");
 		}
-		if (evt.target.tagName === "IMG") {
+		if (evt.target.tagName === "IMG" || evt.target.tagName === "VIDEO") {
 			var current = document.querySelector(".img.selected");
 			if (current) {
 				current.classList = "img";
@@ -308,93 +172,15 @@ func (ch *CaddyHugo) serveMediaPage(w http.ResponseWriter, r *http.Request) (int
 		}
 	}
 	</script></body><html>`)
-	return 200, nil
+	return nil
 }
 
-var (
-	sizeString = regexp.MustCompile(`([0-9]*)(x)?([0-9]*)`)
-)
-
-func parseSizeString(str string, actual image.Rectangle) (image.Rectangle, error) {
-	var err = fmt.Errorf("expected a size string {width}x{height}, saw %q", str)
-
-	strs := sizeString.FindStringSubmatch(str)
-	if len(strs) < 4 {
-		return image.ZR, err
-	}
-
-	var w, h int
-	var strconvErr error
-
-	if strs[1] != "" {
-		w, strconvErr = strconv.Atoi(strs[1])
-		if strconvErr != nil {
-			return image.ZR, err
-		}
-	}
-
-	if strs[3] != "" {
-		h, strconvErr = strconv.Atoi(strs[3])
-		if strconvErr != nil {
-			return image.ZR, err
-		}
-	}
-
-	if strs[2] != "x" {
-		// w was the only dimension given, so set it to the greater dimension
-		// of the actual image size
-		if actual.Dx() > actual.Dy() {
-			w = w
-			h = 0
-		} else {
-			h = w
-			w = 0
-		}
-	}
-
-	return image.Rect(0, 0, w, h), nil
-}
-
-func (ch *CaddyHugo) serveMedia(w http.ResponseWriter, r *http.Request) (int, error) {
+func (ch *CaddyHugo) serveMedia(w http.ResponseWriter, r *http.Request) error {
 	if ch.Media == nil {
 		http.NotFound(w, r)
-		return 404, nil
+		return nil
 	}
 
-	segs := strings.Split(r.URL.Path, "/")
-	name := segs[len(segs)-1] // the last segment is the filename
-
-	size := image.Rectangle{}
-
-	m := ch.Media.ByName(name)
-
-	if len(segs) >= 4 && len(segs) > 2 {
-		var err error
-		size, err = parseSizeString(segs[len(segs)-2], m.Size)
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusBadRequest)
-			return 400, nil
-		}
-	}
-
-	file, err := ch.Media.Thumb(*m, size)
-	if err != nil {
-		http.Error(w, fmt.Sprintf("unable to load thumb"), http.StatusInternalServerError)
-		return 500, nil
-	}
-
-	if file[0] == '/' {
-		file = file[1:]
-	}
-
-	file = path.Join(ch.Media.ThumbDir, file)
-
-	http.ServeFile(w, r, file)
-
-	return 200, nil
-}
-
-func removeExtension(name string) string {
-	ext := path.Ext(name)
-	return name[:len(name)-len(ext)]
+	ch.Media.ServeHTTP(w, r)
+	return nil
 }

media/image.go

@@ -0,0 +1,50 @@
+package media
+
+import (
+	"image"
+	"image/jpeg"
+	"os"
+	"path"
+
+	"github.com/nfnt/resize"
+)
+
+func imageSize(name string) (image.Rectangle, error) {
+	f, err := os.Open(name)
+	if err != nil {
+		return image.ZR, err
+	}
+	defer f.Close()
+
+	cfg, _, err := image.DecodeConfig(f)
+	if err != nil {
+		return image.ZR, err
+	}
+
+	width := cfg.Width
+	height := cfg.Height
+
+	return image.Rect(0, 0, width, height), nil
+}
+
+func ThumbImage(filename string, img image.Image, size image.Rectangle) error {
+	os.MkdirAll(path.Dir(filename), 0755)
+	fthumb, err := os.OpenFile(filename, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0655)
+	if err != nil {
+		return err
+	}
+
+	img = resize.Resize(uint(size.Dx()), uint(size.Dy()), img, resize.Bilinear)
+
+	err = jpeg.Encode(fthumb, img, nil)
+	if err != nil {
+		return err
+	}
+
+	err = fthumb.Close()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

media/media.go

@@ -0,0 +1,199 @@
+package media
+
+import (
+	"image"
+	"io"
+	"net/http"
+	"os"
+	"path"
+	"path/filepath"
+	"sort"
+	"time"
+
+	// for processing images
+	_ "image/gif"
+	_ "image/png"
+
+	"github.com/tajtiattila/metadata"
+)
+
+const (
+	TypeImage = "image"
+	TypeVideo = "video"
+)
+
+type MediaSource struct {
+	StorageDir string
+	ThumbDir   string
+
+	set Set
+}
+
+type Media struct {
+	Type     string
+	Name     string
+	Size     image.Rectangle
+	FullName string
+
+	ms       *MediaSource
+	metadata *metadata.Metadata
+}
+
+func (m Media) ThumbPath(size image.Rectangle) string {
+	return "/" + thumbPath(size, m.Name)
+}
+
+func (m Media) ThumbFilename(size image.Rectangle) string {
+	size = m.NormalizeSize(size)
+	return thumbFilename(m.ms.ThumbDir, size, m.Name)
+}
+
+func (ms *MediaSource) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	m, err := ms.ByName(path.Base(r.URL.Path))
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	sizeRequested, err := SizeRequested(r.URL.Path, m.Size)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	size, err := ms.Thumb(*m, sizeRequested)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	http.ServeFile(w, r, m.ThumbFilename(size))
+}
+
+func (ms *MediaSource) ReceiveNewMedia(name string, r io.Reader) error {
+	ms.set = nil
+
+	dest := path.Join(ms.StorageDir, name)
+	f, err := os.OpenFile(dest, os.O_WRONLY|os.O_CREATE, 0644)
+	if err != nil {
+		return err
+	}
+
+	_, err = io.Copy(f, r)
+	if err != nil {
+		return err
+	}
+
+	return f.Close()
+}
+
+func (m *Media) Date() time.Time {
+	m.getMetadata()
+
+	if m.metadata != nil {
+		raw := m.metadata.Get(metadata.DateTimeOriginal)
+		if raw != "" {
+			d, err := time.Parse("2006-01-02T15:04:05", raw)
+			if err == nil {
+				return d
+			}
+		}
+	}
+
+	fi, err := os.Stat(m.FullName)
+	if err == nil {
+		return fi.ModTime()
+	}
+
+	return time.Time{}
+}
+
+func (m *Media) getMetadata() error {
+	if m.metadata != nil {
+		return nil
+	}
+
+	f, err := os.Open(m.FullName)
+	if err != nil {
+		return err
+	}
+	md, err := metadata.Parse(f)
+	if err != nil {
+		return err
+	}
+	m.metadata = md
+	return nil
+}
+
+func (ms *MediaSource) Size(name string) (image.Rectangle, error) {
+	switch filepath.Ext(name) {
+	case ".mp4":
+		return VideoSize(name)
+	}
+
+	return imageSize(name)
+}
+
+func (ms *MediaSource) ByName(name string) (*Media, error) {
+	ext := filepath.Ext(name)
+	typ := TypeImage
+
+	switch ext {
+	case ".mp4":
+		typ = TypeVideo
+	}
+
+	fullName := path.Join(ms.StorageDir, name)
+	size, _ := ms.Size(fullName)
+
+	return &Media{
+		Type:     typ,
+		Name:     name,
+		Size:     size,
+		FullName: fullName,
+		ms:       ms,
+	}, nil
+}
+
+func (ms *MediaSource) Walk() ([]*Media, error) {
+	if ms.set == nil {
+		var media []*Media
+
+		err := filepath.Walk(ms.StorageDir, func(name string, fi os.FileInfo, err error) error {
+			if err != nil {
+				return err
+			}
+			if fi.IsDir() {
+				return nil
+			}
+			m, err := ms.ByName(path.Base(name))
+			if err != nil {
+				return nil
+			}
+			media = append(media, m)
+			return nil
+		})
+
+		if err != nil {
+			return media, err
+		}
+
+		ms.set = media
+	}
+
+	return ms.set, nil
+}
+
+type Set []*Media
+
+func (s Set) ByDate() Set {
+	sort.Slice(s, func(i, j int) bool {
+		return s[i].Date().After(s[j].Date())
+	})
+	return s
+}
+
+func removeExtension(name string) string {
+	ext := path.Ext(name)
+	return name[:len(name)-len(ext)]
+}

media/media_test.go

@@ -0,0 +1,49 @@
+package media
+
+import (
+	"fmt"
+	"image"
+	"testing"
+)
+
+// TestThumbSizeStrings tests parsing various size strings, which doesn't include
+// scaling zeros, but does use the actual image size to infer single-dimension
+// strings
+func TestThumbSizeStrings(t *testing.T) {
+	type testcase struct {
+		input      string
+		actualSize image.Rectangle
+		expect     image.Rectangle
+	}
+
+	i50x100 := image.Rect(0, 0, 50, 100)
+	i100x100 := image.Rect(0, 0, 100, 100)
+
+	var cases = []testcase{
+		{"100x100", i100x100, image.Rect(0, 0, 100, 100)},
+		{"x100", i100x100, image.Rect(0, 0, 0, 100)},
+		{"100x", i100x100, image.Rect(0, 0, 100, 0)},
+		{"100", i100x100, image.Rect(0, 0, 100, 0)},
+
+		{"100x100", i50x100, image.Rect(0, 0, 100, 100)},
+		{"x100", i50x100, image.Rect(0, 0, 0, 100)},
+		{"100x", i50x100, image.Rect(0, 0, 100, 0)},
+		{"100", i50x100, image.Rect(0, 0, 0, 100)},
+	}
+
+	for _, c := range cases {
+		t.Run(fmt.Sprint(c.input, "=>", c.actualSize), func(t *testing.T) {
+			got, err := ParseSizeString(c.input, image.Rect(0, 0, 100, 100))
+			if err != nil {
+				t.Errorf("error parsing size string: %v", err)
+				return
+			}
+
+			if !got.Eq(c.expect) {
+				t.Errorf("expected %v, got %v", c.expect, got)
+				return
+			}
+
+		})
+	}
+}

media/size.go

@@ -0,0 +1,88 @@
+package media
+
+import (
+	"fmt"
+	"image"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+var (
+	sizeString = regexp.MustCompile(`([0-9]*)(x)?([0-9]*)`)
+)
+
+func SizeRequested(urlpath string, actual image.Rectangle) (image.Rectangle, error) {
+	segments := strings.Count(urlpath, "/")
+	if segments < 3 {
+		return actual, nil
+	}
+	sizeSpec := strings.Split(urlpath, "/")[2]
+	return ParseSizeString(sizeSpec, actual)
+}
+
+func ParseSizeString(str string, actual image.Rectangle) (image.Rectangle, error) {
+	var err = fmt.Errorf("expected a size string {width}x{height}, saw %q", str)
+
+	strs := sizeString.FindStringSubmatch(str)
+	if len(strs) < 4 {
+		return image.ZR, err
+	}
+
+	var w, h int
+	var strconvErr error
+
+	if strs[1] != "" {
+		w, strconvErr = strconv.Atoi(strs[1])
+		if strconvErr != nil {
+			return image.ZR, err
+		}
+	}
+
+	if strs[3] != "" {
+		h, strconvErr = strconv.Atoi(strs[3])
+		if strconvErr != nil {
+			return image.ZR, err
+		}
+	}
+
+	if strs[2] != "x" {
+		// w was the only dimension given, so set it to the greater dimension
+		// of the actual image size
+		if actual.Dx() > actual.Dy() {
+			h = 0
+		} else {
+			h = w
+			w = 0
+		}
+	}
+
+	return image.Rect(0, 0, w, h), nil
+}
+
+func NormalizeSize(media, requested image.Rectangle) image.Rectangle {
+	if requested.Dx() == 0 && requested.Dy() == 0 {
+		return media
+	}
+	if requested.Dy()%2 == 1 {
+		requested.Max.Y--
+	}
+	if requested.Dx() != 0 && requested.Dy() != 0 {
+		return requested
+	}
+	scaled := image.Rectangle{}
+	if requested.Dx() == 0 {
+		scaled.Max.Y = requested.Dy()
+		scaled.Max.X = requested.Dy() * media.Dx() / media.Dy()
+	}
+	if requested.Dy() == 0 {
+		scaled.Max.X = requested.Dx()
+		scaled.Max.Y = requested.Dx() * media.Dy() / media.Dx()
+		for scaled.Max.Y%2 == 1 {
+			requested.Max.X--
+			scaled.Max.X = requested.Dx()
+			scaled.Max.Y = requested.Dx() * media.Dy() / media.Dx()
+		}
+	}
+	return scaled
+}

media/thumb.go

@@ -0,0 +1,110 @@
+package media
+
+import (
+	"fmt"
+	"image"
+	"io"
+	"os"
+	"path"
+	"path/filepath"
+)
+
+func (ms *MediaSource) ThumbPath(m Media, size image.Rectangle) string {
+	size = m.NormalizeSize(size)
+	return thumbPath(size, m.Name)
+}
+
+func (ms *MediaSource) ThumbFilename(m Media, size image.Rectangle) string {
+	size = m.NormalizeSize(size)
+	return thumbFilename(ms.ThumbDir, size, m.Name)
+}
+
+func thumbFilename(dir string, size image.Rectangle, name string) string {
+	return filepath.Join(dir, thumbPath(size, name))
+}
+
+func thumbPath(size image.Rectangle, name string) string {
+	w := size.Dx()
+	h := size.Dy()
+
+	var ws, hs string
+
+	if w != 0 {
+		ws = fmt.Sprint(w)
+	}
+	if h != 0 {
+		hs = fmt.Sprint(h)
+	}
+
+	thumbSlug := filepath.Join(fmt.Sprintf("%sx%s", ws, hs), name)
+	return path.Join("", "media", thumbSlug)
+}
+
+func (ms *MediaSource) ThumbMax(m Media, maxDim int) (image.Rectangle, error) {
+	width := m.Size.Dx()
+	height := m.Size.Dy()
+
+	if width == 0 && height == 0 {
+		return m.Size, fmt.Errorf("invalid media")
+	}
+
+	if width > height {
+		height = height * maxDim / width
+		width = maxDim
+	} else {
+		width = width * maxDim / height
+		height = maxDim
+	}
+
+	size := image.Rect(0, 0, width, height)
+	actual, err := ms.Thumb(m, size)
+	return actual, err
+}
+
+func (ms *MediaSource) HasThumb(m Media, size image.Rectangle) bool {
+	fi, err := os.Stat(ms.ThumbFilename(m, size))
+	if err != nil {
+		return false
+	}
+	return m.Date().Before(fi.ModTime())
+}
+
+func (m Media) NormalizeSize(size image.Rectangle) image.Rectangle {
+	return NormalizeSize(m.Size, size)
+}
+
+func (ms *MediaSource) Thumb(m Media, size image.Rectangle) (image.Rectangle, error) {
+	size = m.NormalizeSize(size)
+
+	if ms.HasThumb(m, size) {
+		return size, nil
+	}
+
+	f, err := os.Open(m.FullName)
+	if err != nil {
+		return size, err
+	}
+	defer f.Close()
+
+	return size, ms.thumbReader(f, m, size)
+}
+
+func (ms *MediaSource) thumbReader(r io.Reader, m Media, size image.Rectangle) error {
+	size = m.NormalizeSize(size)
+
+	switch m.Type {
+	case TypeImage:
+		img, _, err := image.Decode(r)
+		if err != nil {
+			return err
+		}
+
+		filename := ms.ThumbFilename(m, size)
+		return ThumbImage(filename, img, size)
+	case TypeVideo:
+		return VideoEncode(m.FullName, size, ms.ThumbDir)
+
+	default:
+		return fmt.Errorf("cannot thumb media type %q", m.Type)
+	}
+}

media/video.go

@@ -0,0 +1,42 @@
+package media
+
+import (
+	"bytes"
+	"fmt"
+	"image"
+	"os"
+	"os/exec"
+	"path"
+	"path/filepath"
+)
+
+func VideoFrame(filename string) (image.Image, error) {
+	cmd := exec.Command("ffmpeg", "-i", filename, "-vframes", "1", "-f", "singlejpeg", "-")
+	buffer := new(bytes.Buffer)
+	cmd.Stdout = buffer
+	if cmd.Run() != nil {
+		return nil, fmt.Errorf("could not generate frame")
+	}
+
+	img, _, err := image.Decode(buffer)
+	return img, err
+}
+
+func VideoSize(filename string) (image.Rectangle, error) {
+	img, err := VideoFrame(filename)
+	if err != nil {
+		return image.Rectangle{}, err
+	}
+	return img.Bounds(), nil
+}
+
+func VideoEncode(filename string, size image.Rectangle, thumbDir string) error {
+	dest := thumbFilename(thumbDir, size, path.Base(filename))
+	os.MkdirAll(filepath.Dir(dest), 0755)
+	cmd := exec.Command("ffmpeg", "-i", filename, "-vf", fmt.Sprintf("scale=%d:%d", size.Dx(), size.Dy()), "-strict", "-2", dest)
+	if out, err := cmd.CombinedOutput(); err != nil {
+		os.Remove(dest)
+		return fmt.Errorf("could not thumb video: %s", string(out))
+	}
+	return nil
+}

setup.go

@@ -0,0 +1,102 @@
+package caddyhugo
+
+import (
+	"fmt"
+	"html/template"
+	"os"
+	"path"
+
+	"git.stephensearles.com/stephen/caddy-hugo2/comments"
+	"git.stephensearles.com/stephen/caddy-hugo2/media"
+
+	"github.com/gohugoio/hugo/hugofs"
+)
+
+var eventHookCounter uint64
+
+/*
+func SetupCaddy(c *caddy.Controller) error {
+	ch := &CaddyHugo{}
+
+	ch.Site = httpserver.GetConfig(c)
+	root, err := filepath.Abs(ch.Site.Root)
+	if err != nil {
+		return err
+	}
+	err = ch.Setup(root)
+
+	c.OnShutdown(func() error {
+		return ch.persistAllEdits()
+	})
+
+	ch.Site.AddMiddleware(ch.Middleware(c))
+	ch.commentsSetting(c)
+
+	return err
+}
+*/
+
+func (ch *CaddyHugo) commentsSetting() {
+	if ch.Site.CommentsEnabled {
+		ch.Comments = comments.WithStorage(comments.NewDiskv(path.Join(ch.Site.Root, "comments")))
+		if ch.Site.CommentsPassword != "" {
+			ch.Comments.Password = ch.Site.CommentsPassword
+		}
+	}
+}
+
+func (ch *CaddyHugo) Setup(dir string) error {
+	var err error
+
+	ch.log("setting up caddy-hugo in", dir)
+	ch.Dir = dir
+	ch.docs = make(map[string]*editSession)
+	ch.confirmingToClient = make(map[uint64]struct{})
+
+	ch.HugoSites, ch.HugoCfg, err = ch.configWithFs(hugofs.Os)
+	if err != nil {
+		return fmt.Errorf("error setting up hugo : %v", err)
+	}
+
+	err = ch.Build()
+	if err != nil {
+		return fmt.Errorf("error building initial hugo: %v", err)
+	}
+
+	ch.authorTmpl, err = template.New("").Parse(AuthorPage)
+	if err != nil {
+		return fmt.Errorf("author template invalid: %v", err)
+	}
+
+	ch.adminTmpl, err = template.New("").Parse(AdminPage)
+	if err != nil {
+		return fmt.Errorf("admin template invalid: %v", err)
+	}
+
+	ch.editTmpl, err = template.New("").Parse(EditPage)
+	if err != nil {
+		return fmt.Errorf("edit template invalid: %v", err)
+	}
+
+	ch.Media = &media.MediaSource{
+		StorageDir: path.Join(dir, "media"),
+		ThumbDir:   path.Join(dir, "thumbs"),
+	}
+
+	err = os.MkdirAll(ch.Media.StorageDir, 0755)
+	if err != nil {
+		return fmt.Errorf("couldn't initialize media: %v", err)
+	}
+
+	err = writeThemeFiles(ch.Dir)
+	if err != nil {
+		fmt.Println("error installing theme files:", err)
+	}
+
+	err = ch.Publish()
+	if err != nil {
+		fmt.Println("error with initial publish of hugo site:", err)
+	}
+
+	return nil
+}

templates.go

@@ -1,46 +1,26 @@
 package caddyhugo
 
 import (
+	"bytes"
 	"encoding/base64"
 	"fmt"
+	"html/template"
 	"net/http"
 	"os"
 	"path"
 	"path/filepath"
 	"strings"
-	"time"
+	"sync"
 
 	"git.stephensearles.com/stephen/acedoc"
-
-	"github.com/mholt/caddy/caddyhttp/httpserver"
-	"github.com/spf13/hugo/hugolib"
+	"git.stephensearles.com/stephen/caddy-hugo2/frontend"
 )
 
-type Content struct {
-	Title         string
-	Path          string
-	Date, Lastmod time.Time
+func (t *tmplData) Content() ([]Content, error) {
+	return GetContent(t.Site.Root, t.HugoSites)
 }
 
-func (t tmplData) Content() ([]Content, error) {
-	var files []Content
-
-	pages := t.HugoSites.Pages().ByDate()
-	for _, page := range pages {
-		if page.Kind == hugolib.KindPage {
-			files = append(files, Content{
-				Title:   page.Title,
-				Path:    path.Join("content", page.Source.Path()),
-				Date:    page.Date,
-				Lastmod: page.Lastmod,
-			})
-		}
-	}
-
-	return files, nil
-}
-
-func (t tmplData) ContentTypes() ([]string, error) {
+func (t *tmplData) ContentTypes() ([]string, error) {
 	nameMap := map[string]struct{}{"default": struct{}{}}
 
 	names, err := t.contentTypes(path.Join(t.Site.Root, "archetypes"))
@@ -67,7 +47,7 @@ func (t tmplData) ContentTypes() ([]string, error) {
 	return out, nil
 }
 
-func (t tmplData) contentTypes(dir string) ([]string, error) {
+func (t *tmplData) contentTypes(dir string) ([]string, error) {
 	layoutDir, err := os.Open(path.Join(t.Site.Root, "archetypes"))
 	if err != nil {
 		fmt.Println("opening layout dir", err)
@@ -85,14 +65,14 @@ func (t tmplData) contentTypes(dir string) ([]string, error) {
 }
 
 type tmplData struct {
-	Site *httpserver.SiteConfig
+	Site SiteConfig
 	R    *http.Request
-	CaddyHugo
+	*CaddyHugo
 	Doc    *acedoc.Document
-	docref *docref
+	docref *editSession
 }
 
-func (t tmplData) LoadContent() (string, error) {
+func (t *tmplData) LoadContent() (string, error) {
 	return t.Doc.Contents(), nil
 }
 
@@ -101,405 +81,38 @@ func baseNoExt(name string) string {
 	return base[:len(base)-len(path.Ext(base))]
 }
 
-func (t tmplData) IframeSource() string {
-	name := baseNoExt(t.docref.name)
-	ctype := baseNoExt(path.Dir(t.docref.name))
+func (t *tmplData) IframeSource() string {
+	name := baseNoExt(t.docref.docname)
+	ctype := baseNoExt(path.Dir(t.docref.docname))
 	if ctype == "content" {
-		return fmt.Sprintf("/hugo/draft/%s/%s/", base64.RawURLEncoding.EncodeToString([]byte(t.docref.name)), strings.Replace(name, " ", "-", -1))
+		return fmt.Sprintf("/hugo/draft/%s/%s/", base64.RawURLEncoding.EncodeToString([]byte(t.docref.docname)), strings.Replace(name, " ", "-", -1))
 	}
-	return fmt.Sprintf("/hugo/draft/%s/%s/%s/", base64.RawURLEncoding.EncodeToString([]byte(t.docref.name)), ctype, strings.Replace(name, " ", "-", -1))
+	return fmt.Sprintf("/hugo/draft/%s/%s/%s/", base64.RawURLEncoding.EncodeToString([]byte(t.docref.docname)), ctype, strings.Replace(name, " ", "-", -1))
 }
 
-var EditPage = `<html>
-<head>
-<script src="/hugo/simplemde.js"></script>
-<style type="text/css" media="screen">
-#editor-wrapper { 
-	position: absolute;
-	top: 50px;
-	right: 0;
-	bottom: 150px;
-	left: 40%;
-}
-#draft {
-	position: absolute;
-	top: 50px;
-	right: 60%;
-	bottom: 0;
-	left: 0;
+var EditPage = frontend.EditPage()
 
-}
-#draft > iframe {
-	height: 100%;
-	width: 100%;
-	border: none;
-}
-a {
-	text-decoration: underline;
-	text-decoration-style: dotted;
-	cursor: pointer;
-}
-</style>
-<link rel="stylesheet" href="/hugo/simplemde.css" />
-<script src="https://unpkg.com/vue"></script>
-<script src="https://unpkg.com/moment"></script>
+var AdminPage = frontend.AdminPage()
 
+var AuthorPage = frontend.AuthorPage()
 
-<body>
-<div id="container" >
-	<div id="header">
-		<div id="lastSaved">
-			<span v-if="ltime >serverLtime && (sendQueue.length > 0 || sentRecently.length > 0)">last saved ${ lastSaved.from(now) }, saving</span>
-			<span v-else>saved</span>
-			<span v-if="connectionError">, ${connectionError}</span>
-		</div>
-		<div>
-			<a id="sideview-toggle-media">media</a>
-			<a id="sideview-toggle-draft">draft</a>
-		</div>
-	</div>
-	<div id="editor-wrapper">
-		<textarea id="editor">{{ .LoadContent }}</textarea>
-	</div>
-	<div id="draft"><iframe src="{{ .IframeSource }}">Loading draft...</iframe></div>
-</div>
-<script>
-
-    var iframe = document.querySelector("#draft > iframe");
-
-    document.onclick = function (event) {
-	    var iframe = document.querySelector("#draft > iframe");
-	    switch (event.target.id) {
-	    case "sideview-toggle-media":
-		    iframe.src = "/hugo/media";
-		    break;
-	    case "sideview-toggle-draft":
-		    iframe.src = "{{ .IframeSource }}";
-		    break;
-	    }
-    }
-
-    var uiBindings = {
-	    ltime: 0,
-	    serverLtime: 0,
-	    lastSaved: moment(),
-	    now: moment(),
-	    connectionError: null,
-	    sendQueue: [],
-	    sentRecently: [],
-    };
-
-    var app = new Vue({
-	    el: "#container",
-	    data: uiBindings,
-	    delimiters: ["${", "}"],
-    });
-
-    function getLtime() {
-	    uiBindings.ltime++
-	    return uiBindings.ltime
-    }
-
-    function observeServer(l) {
-	    uiBindings.serverLtime = l;
-	    while (uiBindings.sentRecently.length > 0 && uiBindings.sentRecently[0].ltime < l) {
-		    uiBindings.sentRecently.pop();
-	    }
-	    observe(l);
-    }
-
-    function observe(l) {
-	 if (l > uiBindings.ltime) { 
-		 uiBindings.now = moment();
-		 uiBindings.lastSaved = moment();
-		 uiBindings.ltime = l;
-	 }
-    }
-
-    var selectedImage;
-    var editorElem = document.getElementById("editor");
-    var editor = new SimpleMDE({
-	    element: editorElem,
-	    forceSync: true,
-	    insertTexts: {
-		    image: ["{\{% thumb filename=\"", "#url#\" width=\"200\" %}}"]
-	    },
-	    imageURLFn: function () {
-		    return selectedImage;
-	    }
-    });
-
-    window.onmessage = function (evt) {
-	    selectedImage = evt.data;
-    }
-
-
-    // Create WebSocket connection.
-    var socket = connect();
-
-
-    const sawChangesBumpsTo = 10;
-
-    var sawChanges = -1;
-    window.setInterval(function () {
-	    if (sawChanges >= 0) {
-		    sawChanges--;
-		    if (sawChanges == 0) {
-			    iframe.contentWindow.location.reload();
-		    }
-	    }
-	    uiBindings.now = moment();
-	    if (uiBindings.connectionError) {
-		    socket = connect();
-	    } else if (uiBindings.sendQueue.length > 0) {
-		    var ltime = getLtime();
-		    socket.send(JSON.stringify({
-			    "deltas": uiBindings.sendQueue,
-			    "ltime": ltime,
-		    }));
-		    uiBindings.sentRecently.push({
-			    "ltime": ltime,
-			    "sent": uiBindings.sendQueue,
-		    });
-		    uiBindings.sendQueue = [];
-	    }
-    }, 500);
-
-    function connect() {
-	    const socket = new WebSocket((location.protocol == "https:" ? 'wss://' : 'ws://') + location.host + location.pathname);
-
-	    // Listen for messages
-	    socket.addEventListener('message', function (event) {
-		 var message = JSON.parse(event.data);
-		 observeServer(message.ltime);
-
-		 var deltas = [];
-		 deltas.push.apply(deltas, message.deltas);
-
-		 deltas.forEach(function(aceDelta) {
-			 var cmDelta = aceDeltaToCM(aceDelta)
-
-			 var content = ""
-			 var to = {
-				 line: aceDelta.start.row,
-				 ch: aceDelta.start.column,
-			 }
-
-			 if (aceDelta.action == "insert") {
-				 content = aceDelta.lines.join("\n");
-				 to = null;
-			 }
-
-			 editor.codemirror.doc.replaceRange(content, cmDelta.from, to, "dontreflect");
-			 sawChanges = sawChangesBumpsTo;
-		 })
-	    });
-
-	    socket.addEventListener('open', function () {
-		    uiBindings.connectionError = null;
-	    });
-
-	    socket.addEventListener('close', function () {
-		    if (!uiBindings.connectionError) {
-			    getLtime();
-			    uiBindings.connectionError = "server connection closed, reconnecting...";
-		    }
-	    });
-
-	    socket.addEventListener('error', function (err) {
-		    if (!uiBindings.connectionError) {
-			    uiBindings.connectionError = err;
-		     	    getLtime();
-		    }
-		    console.log(err);
-	    });
-
-
-	    return socket;
-    }
-
-    editor.codemirror.on("change", function (cm, cmDelta) {
-		    if (cmDelta.origin == "dontreflect") {
-			    return;
-		    }
-
-		    var aceDelta = cmDeltaToAce(cmDelta);
-		    console.log(cmDelta, "=>", aceDelta)
-
-		    sawChanges = sawChangesBumpsTo;
-		    uiBindings.sendQueue.push.apply(uiBindings.sendQueue, aceDelta);
-    })
-
-    function cmDeltaToAce(cmDelta) {
-	    var isRemove =  (cmDelta.removed.length > 0 && cmDelta.removed[0].length > 0) || cmDelta.removed.length > 1;
-	    var lines = isRemove ? cmDelta.removed : cmDelta.text;
-	    var aceDelta = {
-		    action: isRemove ? "remove" : "insert",
-		    lines: lines,
-		    start: {
-			    row: cmDelta.from.line,
-			    column: cmDelta.from.ch,
-		    },
-		    end: {
-			    row: cmDelta.from.line + (isRemove ? lines.length - 1 : lines.length - 1 ),
-			    column: lines[lines.length-1].length,
-		    }
-	    };
-
-	    if (aceDelta.start.row == aceDelta.end.row) {
-		    aceDelta.end.column += cmDelta.from.ch;
-	    }
-
-	    if (false && isRemove && aceDelta.start.row == aceDelta.end.row) {
-		    var origStart = aceDelta.start;
-		    aceDelta.start = aceDelta.end;
-		    aceDelta.end = origStart;
-		    aceDelta.start.column += cmDelta.from.ch;
-	    }
-
-	    if (isRemove && ((cmDelta.text.length > 0 && cmDelta.text[0].length > 0) || cmDelta.text.length > 1)) {
-		    cmDelta.removed = [""];
-		    var ret = [aceDelta];
-		    ret.push.apply(ret, cmDeltaToAce(cmDelta));
-		    return ret;
-	    }
-
-	    return [aceDelta];
-    }
-
-    function aceDeltaToCM(aceDelta) {
-
-	    var cmDelta = {
-		    text: [],
-		    removed: [],
-		    from: {
-			    line: aceDelta.start.row,
-			    ch: aceDelta.start.column,
-		    },
-		    to: {
-			    // cm deltas are weird. to refers to the selection end, which 
-			    // with a simple blinking cursor with no selection, is always 
-			    // the same as from
-			    line: aceDelta.start.row,
-			    ch: aceDelta.start.column,
-		    },
-	    }
-
-	    if (aceDelta.action == "remove") {
-		    var origStart = aceDelta.start;
-		    aceDelta.start = aceDelta.end;
-		    aceDelta.end = origStart;
-
-		    cmDelta.removed = aceDelta.lines
-		    cmDelta.text = [""]
-	    } else {
-		    cmDelta.text = aceDelta.lines
-		    cmDelta.removed = [""]
-	    }
-
-	    return cmDelta;
-    }
-</script>
-</body>
-</html>`
-
-var AdminPage = `<html><body>not implemented</body></html>`
-
-var AuthorPage = `<html>
-<head>
-</head>
-<body>
-{{ $timeFormat := "Jan _2 15:04:05" }}
-	<p>Create content:</p>
-	<form action="/hugo/edit/new" method="POST">
-		<label>Name: <input type="text" name="name" /></label>
-		<select name="type">
-		    {{- range .ContentTypes }}
-			<option value="{{ . }}">{{ . }}</option>
-		    {{- end }}
-		</select>
-		<input type="submit" />
-	</form>
-
-	<p>Edit content:</p>
-	<table>{{ range .Content }}
-	<tr><td><a href="/hugo/edit/{{ .Path }}">{{ .Title }}</a></td><td>{{ .Date.Format $timeFormat }}{{ if not (.Lastmod.Equal .Date) }} (last modified {{.Lastmod.Format $timeFormat }}){{end}}</td></tr>
-	    {{- end }}
-	</table>
-</body>
-</html>`
+var uploadTmpl *template.Template
+var uploadTmplOnce sync.Once
 
 func UploadPage(elemName string) string {
-	return fmt.Sprintf(`
-	<input type="file" style="display: hidden;" id="%s" />
-	<div id="%s_dropzone" ondrop="dropHandler(event);" ondragover="draghandler(event);" ondragenter="draghandler(event);" ondragleave="draghandler(event);" style="background-color: rgba(0,0,0,0.5); visibility: hidden; opacity:0; position: fixed; top: 0; bottom: 0; left: 0; right: 0; width: 100%; height: 100%; ; transition: visibility 175ms, opacity 175ms; z-index: 9999999;"></div>
-	<script>
-document.addEventListener("DOMContentLoaded", function () {
-	var fileInput = document.getElementById('%s');
-	var dropzone = document.getElementById('%s_dropzone');
-
-	fileInput.onchange = function () {
-		var formData = new FormData();
-		fileInput.files.forEach(function (file) {
-			formData.append(file.name, file);
-		});
-		upload(formData);
+	uploadTmplOnce.Do(func() {
+		p := frontend.UploadPage()
+		t, err := template.New("").Parse(p)
+		if err != nil {
+			panic(err)
 		}
+		uploadTmpl = t
+	})
 
-	var lastTarget = null;
-
-	window.addEventListener("dragenter", function(e)
-	{
-		lastTarget = e.target; // cache the last target here
-		// unhide our dropzone overlay
-		dropzone.style.visibility = "";
-		dropzone.style.opacity = 1;
-	});
-
-	window.addEventListener("dragleave", function(e)
-	{
-		// this is the magic part. when leaving the window,
-		// e.target happens to be exactly what we want: what we cached
-		// at the start, the dropzone we dragged into.
-		// so..if dragleave target matches our cache, we hide the dropzone.
-		if(e.target === lastTarget)
-		{
-			dropzone.style.visibility = "hidden";
-			dropzone.style.opacity = 0;
+	var buf bytes.Buffer
+	err := uploadTmpl.Execute(&buf, struct{ ElemName string }{elemName})
+	if err != nil {
+		panic(err)
 	}
-	});
-
-});
-
-	function draghandler(evt) {
-		evt.preventDefault();
-	}
-
-	function dropHandler(evt) {
-		evt.preventDefault();
-
-		var files = evt.dataTransfer.files;
-		var formData = new FormData();
-
-		for (var i = 0; i < files.length; i++) {
-			formData.append(files[i].name, files[i]);
-		}
-
-		upload(formData);
-		return false;
-	}
-
-	function upload(formData) {
-		var xhr = new XMLHttpRequest();
-		xhr.onreadystatechange = function(e) {
-			if ( 4 == this.readyState ) {
-				window.location.reload(true);
-			}
-		}
-		xhr.open('POST', '/hugo/upload');
-		xhr.send(formData);
-	}
-
-</script>
-`, elemName, elemName, elemName, elemName, elemName, elemName)
+	return buf.String()
 }

testdir/Caddyfile

@@ -0,0 +1,17 @@
+{
+	order hugo last
+}
+
+http://localhost:8080 {
+	hugo {
+		comments test
+	}
+	root ./testdir/testsite
+	log
+}
+
+http://localhost:8081, http://localhost:8082 {
+	root ./testdir/testsite2
+	hugo
+	log
+}

testdir/caddyfile

@@ -1,6 +0,0 @@
-localhost:8080 {
-	hugo
-	root ./testsite
-	errors { * }
-	pprof
-}

testdir/testsite/config.toml

@@ -1,4 +1,3 @@
 baseURL = "http://example.org/"
 languageCode = "en-us"
 title = "My New Hugo Site"
-theme = "hugo-theme-minos"

testdir/testsite2/config.toml

@@ -0,0 +1,3 @@
+baseURL = "http://example.org/"
+languageCode = "en-us"
+title = "My New Hugo Site"

testdir/testsite2/public/categories/index.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
+  <channel>
+    <title>Categories on My New Hugo Site</title>
+    <link>http://example.org/categories/</link>
+    <description>Recent content in Categories on My New Hugo Site</description>
+    <generator>Hugo -- gohugo.io</generator>
+    <language>en-us</language>
+    
+	<atom:link href="http://example.org/categories/index.xml" rel="self" type="application/rss+xml" />
+    
+    
+  </channel>
+</rss>

testdir/testsite2/public/index.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
+  <channel>
+    <title>My New Hugo Site</title>
+    <link>http://example.org/</link>
+    <description>Recent content on My New Hugo Site</description>
+    <generator>Hugo -- gohugo.io</generator>
+    <language>en-us</language>
+    
+	<atom:link href="http://example.org/index.xml" rel="self" type="application/rss+xml" />
+    
+    
+  </channel>
+</rss>

testdir/testsite2/public/sitemap.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
+  xmlns:xhtml="http://www.w3.org/1999/xhtml">
+  
+  <url>
+    <loc>http://example.org/categories/</loc>
+    <priority>0</priority>
+  </url>
+  
+  <url>
+    <loc>http://example.org/</loc>
+    <priority>0</priority>
+  </url>
+  
+  <url>
+    <loc>http://example.org/tags/</loc>
+    <priority>0</priority>
+  </url>
+  
+</urlset>

testdir/testsite2/public/tags/index.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
+  <channel>
+    <title>Tags on My New Hugo Site</title>
+    <link>http://example.org/tags/</link>
+    <description>Recent content in Tags on My New Hugo Site</description>
+    <generator>Hugo -- gohugo.io</generator>
+    <language>en-us</language>
+    
+	<atom:link href="http://example.org/tags/index.xml" rel="self" type="application/rss+xml" />
+    
+    
+  </channel>
+</rss>

theme-additions/archetypes/gallery.md

@@ -0,0 +1,16 @@
++++
+title = ""
+tags = [
+  "gallery"
+]
+categories = [
+  "gallery"
+]
+draft = true
+
+[photos]
+"/media/IMG000.png" = "a great photo"
+"/media/IMG003.png" = ""
+
++++
+

theme-additions/assets.go

@@ -0,0 +1,3 @@
+//go:generate go-bindata -ignore .go -pkg themeadditions ./...
+
+package themeadditions

theme-additions/layouts/gallery/single.html

@@ -0,0 +1,15 @@
+{{ partial "head.html" . }}
+
+<body>
+<div id="container">
+    {{ partial "header.html" . }}
+    <section id="main" class="outer">
+        {{ partial "gallery.html" . }}
+        {{ if and (not .Params.nocomment) .Site.Params.disqusShortname }}
+            {{ template "_internal/disqus.html" . }}
+        {{ end }}
+    </section>
+    {{ partial "footer.html" . }}
+</div>
+</body>
+</html>

theme-additions/layouts/partials/gallery.html

@@ -0,0 +1,152 @@
+<style>
+figure {
+	text-align: center;
+	float: left;
+	margin: 0;
+	max-width: 100%;
+	transition-property: height min-height scale; 
+	transition-duration: 1s;
+}
+.floatclear {
+	clear: both;
+}
+</style>
+<article class="article article-type-post" itemscope itemprop="blogPost">
+    <div class="article-inner">
+        {{ if .Title }}
+        <header class="article-header">
+            <h1 class="article-title" itemprop="name">{{ .Title }}</h1>
+        </header>
+        {{ end }}
+        <div class="article-meta">
+            <a href="{{ .RelPermalink }}" class="article-date">
+                <time datetime='{{ .Date.Format "2006-01-02T15:04:05.000-07:00" }}' itemprop="datePublished">{{ .Date.Format "2006-01-02" }}</time>
+            </a>
+            {{ $Site := .Site }}
+            {{ if .Params.categories }}
+            <div class="post-categories">
+                <div class="article-category">
+                    {{ range $i, $e := .Params.categories }}
+                    {{ if gt $i 0 }}
+                    <span>&gt;</span>
+                    {{ end }}
+                    <a class="article-category-link" href="{{ $Site.BaseURL }}/categories/{{ $e | urlize }}">{{ $e }}</a>
+                    {{ end }}
+                </div>
+            </div>
+            {{ end }}
+            {{ if .Site.Params.disqusShortname }}
+            <div class="article-comment-link-wrap">
+                <a href="{{ .RelPermalink }}#disqus_thread" class="article-comment-link">Comments</a>
+            </div>
+            {{ end }}
+        </div>
+        <div class="article-entry" itemprop="articleBody">
+	    {{ range $i, $_ := .Params.photos }}
+		{{ $splitnum := split .url "/" | len | add -1}}
+		{{ $name := index (split .url "/") $splitnum }}
+		{{ if not $i }}
+		   <figure class="image" id="full-figure" >
+			<img src="/media/{{ $name }}" id="{{$name}}" {{ with .alt }}alt="{{ . }}"{{ end }} data-caption="{{.caption}}"/>
+			<figcaption>{{ with .caption }}{{ . }}{{ end }}</figcaption>
+		   </figure>
+		   <div class="floatclear"></div>
+		{{ end }}
+
+		   <figure class="thumb" >
+			<img src="/media/x100/{{ $name }}" id="{{$name}}" alt="{{ with .alt }}{{ . }}{{ else }}{{ .caption }}{{ end }}" data-name="{{$name}}" data-caption="{{.caption}}"/>
+		   </figure>
+	    {{ end }}
+            <div class="floatclear"></div>
+            {{ .Content }}
+        </div>
+	<script>
+	function getElementIndex(node) {
+            var index = 0;
+            while ( (node = node.previousElementSibling) ) {
+                index++;
+            }
+            return index;
+        }
+
+	var image = document.querySelector("figure.image").firstElementChild;
+	image.parentElement.style.minHeight = image.scrollHeight + "px";
+
+	image.onload = function () {
+		image.parentElement.style.minHeight = '';
+	};
+
+	document.querySelector(".article-entry").onclick = function (evt) {
+		if (evt.target.tagName === "IMG" && evt.target.parentElement.className === "thumb") {
+			image.src = ""
+			image.src = "/media/" + evt.target.dataset.name;
+			image.nextElementSibling.innerText = evt.target.dataset.caption;
+		}
+	}
+	</script>
+
+        {{ if not .Params.notoc }}
+        {{ if .TableOfContents }}
+        <div class="article-toc" {{ if .Site.Params.SmartToc }}style="display:none;"{{ end }}>
+            <h3>Contents</h3>
+            {{ .TableOfContents }}
+        </div>
+        {{ end }}
+        {{ end }}
+
+        {{ if .Site.Params.SmartToc }}
+        <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.1.1/jquery.slim.min.js" integrity="sha256-/SIrNqv8h6QGKDuNoLGA4iret+kyesCkHGzVUUV0shc=" crossorigin="anonymous"></script>
+        <script>
+            (function() {
+                var $toc = $('#TableOfContents');
+                if ($toc.length > 0) {
+                    var $window = $(window);
+
+                    function onScroll(){
+                        var currentScroll = $window.scrollTop();
+                        var h = $('.article-entry h1, .article-entry h2, .article-entry h3, .article-entry h4, .article-entry h5, .article-entry h6');
+                        var id = "";
+                        h.each(function (i, e) {
+                            e = $(e);
+                            if (e.offset().top - 10 <= currentScroll) {
+                                id = e.attr('id');
+                            }
+                        });
+                        var active = $toc.find('a.active');
+                        if (active.length == 1 && active.eq(0).attr('href') == '#' + id) return true;
+
+                        active.each(function (i, e) {
+                            $(e).removeClass('active').siblings('ul').hide();
+                        });
+                        $toc.find('a[href="#' + id + '"]').parentsUntil('#TableOfContents').each(function (i, e) {
+                            $(e).children('a').addClass('active').siblings('ul').show();
+                        });
+                    }
+
+                    $window.on('scroll', onScroll);
+                    $(document).ready(function() {
+                        $toc.find('a').parent('li').find('ul').hide();
+                        onScroll();
+                        document.getElementsByClassName('article-toc')[0].style.display = '';
+                    });
+                }
+            })();
+        </script>
+        {{ end }}
+
+
+        {{ if .Params.tags }}
+        <footer class="article-footer">
+            <ul class="article-tag-list">
+                {{ range .Params.tags }}
+                <li class="article-tag-list-item">
+                    <a class="article-tag-list-link" href="{{ $Site.BaseURL}}/tags/{{ . | urlize }}">{{ . }}
+                    </a>
+                </li>
+                {{ end }}
+            </ul>
+        </footer>
+        {{ end }}
+    </div>
+    {{ partial "nav.html" . }}
+</article>

theme-additions/layouts/shortcodes/comments.html

@@ -0,0 +1,26 @@
+<script>
+                window.onload = function () {
+                        refreshComments();
+                };
+
+                function refreshComments() {
+                        var xhr = new XMLHttpRequest();
+                        xhr.open("GET", "./comments");
+                        xhr.onload = function () {
+                                document.querySelector("#comments").innerHTML = xhr.responseText;
+                        };
+                        xhr.send();
+                }
+
+                window.submitComment = function (evt) {
+                        evt.preventDefault();
+                        var xhr = new XMLHttpRequest();
+                        xhr.open('POST', './comments', true);
+                        xhr.send(JSON.stringify({"text": evt.target.querySelector('textarea').value}));
+                        xhr.onload = function () {
+                                refreshComments();
+                        }
+                }
+</script>
+<div id="comments"></div>
+

theme-additions/layouts/shortcodes/thumb.html

@@ -0,0 +1,17 @@
+{{ $filename := .Get "filename" -}}
+{{ $ext := substr $filename (sub (len $filename) 4) }}
+<p
+{{ if eq (.Get "align") "left" }}class="leftimg"{{else if (.Get "align") "right"}}class="rightimg"{{end }}>
+{{ if eq $ext ".mp4" }}
+<video src="/media/
+{{- with .Get "width"}}{{.}}{{else}}100{{end}}x{{with .Get "height"}}{{.}}{{else}}{{end}}/{{ $filename -}}"
+controls allowfullscreen
+></video>
+{{ else }}
+<a href="/media/{{ $filename }}" target="_blank"><img src="/media/
+{{- with .Get "width"}}{{.}}{{else}}100{{end}}x{{with .Get "height"}}{{.}}{{else}}{{end}}/{{ $filename -}}"
+{{ with .Get "caption" }}title="{{.}}"{{end}}
+{{ with .Get "caption" }}alt="{{.}}"{{end}}
+/></a>
+{{end}}
+</p>

tools.go

@@ -0,0 +1,3 @@
+package caddyhugo
+
+import _ "github.com/caddyserver/xcaddy"