updates

directory/editor.go

@@ -0,0 +1,124 @@
+package directory
+
+import (
+	"bytes"
+	"path/filepath"
+	"strings"
+
+	"github.com/hacdias/caddy-filemanager/frontmatter"
+	"github.com/spf13/hugo/parser"
+)
+
+// Editor contains the information for the editor page
+type Editor struct {
+	Class       string
+	Mode        string
+	Content     string
+	FrontMatter *frontmatter.Content
+}
+
+// GetEditor gets the editor based on a FileInfo struct
+func (i *Info) GetEditor() (*Editor, error) {
+	// Create a new editor variable and set the mode
+	editor := new(Editor)
+	editor.Mode = strings.TrimPrefix(filepath.Ext(i.Name), ".")
+
+	switch editor.Mode {
+	case "md", "markdown", "mdown", "mmark":
+		editor.Mode = "markdown"
+	case "asciidoc", "adoc", "ad":
+		editor.Mode = "asciidoc"
+	case "rst":
+		editor.Mode = "rst"
+	case "html", "htm":
+		editor.Mode = "html"
+	case "js":
+		editor.Mode = "javascript"
+	}
+
+	var page parser.Page
+	var err error
+
+	// Handle the content depending on the file extension
+	switch editor.Mode {
+	case "markdown", "asciidoc", "rst":
+		if editor.hasFrontMatterRune(i.Raw) {
+			// Starts a new buffer and parses the file using Hugo's functions
+			buffer := bytes.NewBuffer(i.Raw)
+			page, err = parser.ReadFrom(buffer)
+			if err != nil {
+				return editor, err
+			}
+
+			// Parses the page content and the frontmatter
+			editor.Content = strings.TrimSpace(string(page.Content()))
+			editor.FrontMatter, _, err = frontmatter.Pretty(page.FrontMatter())
+			editor.Class = "complete"
+		} else {
+			// The editor will handle only content
+			editor.Class = "content-only"
+			editor.Content = i.Content
+		}
+	case "json", "toml", "yaml":
+		// Defines the class and declares an error
+		editor.Class = "frontmatter-only"
+
+		// Checks if the file already has the frontmatter rune and parses it
+		if editor.hasFrontMatterRune(i.Raw) {
+			editor.FrontMatter, _, err = frontmatter.Pretty(i.Raw)
+		} else {
+			editor.FrontMatter, _, err = frontmatter.Pretty(editor.appendFrontMatterRune(i.Raw, editor.Mode))
+		}
+
+		// Check if there were any errors
+		if err != nil {
+			return editor, err
+		}
+	default:
+		// The editor will handle only content
+		editor.Class = "content-only"
+		editor.Content = i.Content
+	}
+	return editor, nil
+}
+
+func (e Editor) hasFrontMatterRune(file []byte) bool {
+	return strings.HasPrefix(string(file), "---") ||
+		strings.HasPrefix(string(file), "+++") ||
+		strings.HasPrefix(string(file), "{")
+}
+
+func (e Editor) appendFrontMatterRune(frontmatter []byte, language string) []byte {
+	switch language {
+	case "yaml":
+		return []byte("---\n" + string(frontmatter) + "\n---")
+	case "toml":
+		return []byte("+++\n" + string(frontmatter) + "\n+++")
+	case "json":
+		return frontmatter
+	}
+
+	return frontmatter
+}
+
+// CanBeEdited checks if the extension of a file is supported by the editor
+func CanBeEdited(filename string) bool {
+	extensions := [...]string{
+		"md", "markdown", "mdown", "mmark",
+		"asciidoc", "adoc", "ad",
+		"rst",
+		".json", ".toml", ".yaml",
+		".css", ".sass", ".scss",
+		".js",
+		".html",
+		".txt",
+	}
+
+	for _, extension := range extensions {
+		if strings.HasSuffix(filename, extension) {
+			return true
+		}
+	}
+
+	return false
+}

directory/file.go

@@ -0,0 +1,327 @@
+package directory
+
+import (
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/dustin/go-humanize"
+	"github.com/hacdias/caddy-filemanager/config"
+	p "github.com/hacdias/caddy-filemanager/page"
+	"github.com/hacdias/caddy-filemanager/utils/errors"
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+)
+
+// Info is the information about a particular file or directory
+type Info struct {
+	IsDir    bool
+	Name     string
+	Size     int64
+	URL      string
+	Path     string // The relative Path of the file/directory relative to Caddyfile.
+	RootPath string // The Path of the file/directory on http.FileSystem.
+	ModTime  time.Time
+	Mode     os.FileMode
+	Mimetype string
+	Content  string
+	Raw      []byte
+	Type     string
+}
+
+// GetInfo gets the file information and, in case of error, returns the
+// respective HTTP error code
+func GetInfo(url *url.URL, c *config.Config) (*Info, int, error) {
+	var err error
+
+	rootPath := strings.Replace(url.Path, c.BaseURL, "", 1)
+	rootPath = strings.TrimPrefix(rootPath, "/")
+	rootPath = "/" + rootPath
+
+	relpath := c.PathScope + rootPath
+	relpath = strings.Replace(relpath, "\\", "/", -1)
+	relpath = filepath.Clean(relpath)
+
+	file := &Info{
+		URL:      url.Path,
+		RootPath: rootPath,
+		Path:     relpath,
+	}
+	f, err := c.Root.Open(rootPath)
+	if err != nil {
+		return file, errors.ToHTTPCode(err), err
+	}
+	defer f.Close()
+
+	info, err := f.Stat()
+	if err != nil {
+		return file, errors.ToHTTPCode(err), err
+	}
+
+	file.IsDir = info.IsDir()
+	file.ModTime = info.ModTime()
+	file.Name = info.Name()
+	file.Size = info.Size()
+	return file, 0, nil
+}
+
+// GetExtendedInfo is used to get extra parameters for FileInfo struct
+func (i *Info) GetExtendedInfo() error {
+	err := i.Read()
+	if err != nil {
+		return err
+	}
+
+	i.Type = SimplifyMimeType(i.Mimetype)
+	return nil
+}
+
+// Read is used to read a file and store its content
+func (i *Info) Read() error {
+	raw, err := ioutil.ReadFile(i.Path)
+	if err != nil {
+		return err
+	}
+	i.Mimetype = http.DetectContentType(raw)
+	i.Content = string(raw)
+	i.Raw = raw
+	return nil
+}
+
+// HumanSize returns the size of the file as a human-readable string
+// in IEC format (i.e. power of 2 or base 1024).
+func (i Info) HumanSize() string {
+	return humanize.IBytes(uint64(i.Size))
+}
+
+// HumanModTime returns the modified time of the file as a human-readable string.
+func (i Info) HumanModTime(format string) string {
+	return i.ModTime.Format(format)
+}
+
+// Delete handles the delete requests
+func (i *Info) Delete() (int, error) {
+	var err error
+
+	// If it's a directory remove all the contents inside
+	if i.IsDir {
+		err = os.RemoveAll(i.Path)
+	} else {
+		err = os.Remove(i.Path)
+	}
+
+	if err != nil {
+		return errors.ToHTTPCode(err), err
+	}
+
+	return http.StatusOK, nil
+}
+
+// Rename function is used tor rename a file or a directory
+func (i *Info) Rename(w http.ResponseWriter, r *http.Request) (int, error) {
+	newname := r.Header.Get("Rename-To")
+	if newname == "" {
+		return http.StatusBadRequest, nil
+	}
+
+	newpath := filepath.Clean(newname)
+	newpath = strings.Replace(i.Path, i.Name, newname, 1)
+
+	if err := os.Rename(i.Path, newpath); err != nil {
+		return errors.ToHTTPCode(err), err
+	}
+
+	i.Path = newpath
+	return http.StatusOK, nil
+}
+
+// ServeAsHTML is used to serve single file pages
+func (i *Info) ServeAsHTML(w http.ResponseWriter, r *http.Request, c *config.Config) (int, error) {
+	if i.IsDir {
+		return i.serveListing(w, r, c)
+	}
+
+	return i.serveSingleFile(w, r, c)
+}
+
+func (i *Info) serveSingleFile(w http.ResponseWriter, r *http.Request, c *config.Config) (int, error) {
+	err := i.GetExtendedInfo()
+	if err != nil {
+		return errors.ToHTTPCode(err), err
+	}
+
+	if i.Type == "blob" {
+		return i.ServeRawFile(w, r, c)
+	}
+
+	page := &p.Page{
+		Info: &p.Info{
+			Name:   i.Name,
+			Path:   i.RootPath,
+			IsDir:  false,
+			Data:   i,
+			Config: c,
+		},
+	}
+
+	if CanBeEdited(i.Name) {
+		editor, err := i.GetEditor()
+
+		if err != nil {
+			return http.StatusInternalServerError, err
+		}
+
+		page.Info.Data = editor
+		return page.PrintAsHTML(w, "frontmatter", "editor")
+	}
+
+	return page.PrintAsHTML(w, "single")
+}
+
+func (i *Info) serveListing(w http.ResponseWriter, r *http.Request, c *config.Config) (int, error) {
+	var err error
+
+	file, err := c.Root.Open(i.RootPath)
+	if err != nil {
+		return errors.ToHTTPCode(err), err
+	}
+	defer file.Close()
+
+	listing, err := i.loadDirectoryContents(file, c)
+	if err != nil {
+		fmt.Println(err)
+		switch {
+		case os.IsPermission(err):
+			return http.StatusForbidden, err
+		case os.IsExist(err):
+			return http.StatusGone, err
+		default:
+			return http.StatusInternalServerError, err
+		}
+	}
+
+	listing.Context = httpserver.Context{
+		Root: c.Root,
+		Req:  r,
+		URL:  r.URL,
+	}
+
+	// Copy the query values into the Listing struct
+	var limit int
+	listing.Sort, listing.Order, limit, err = handleSortOrder(w, r, c.PathScope)
+	if err != nil {
+		return http.StatusBadRequest, err
+	}
+
+	listing.applySort()
+
+	if limit > 0 && limit <= len(listing.Items) {
+		listing.Items = listing.Items[:limit]
+		listing.ItemsLimitedTo = limit
+	}
+
+	page := &p.Page{
+		Info: &p.Info{
+			Name:   listing.Name,
+			Path:   i.RootPath,
+			IsDir:  true,
+			Config: c,
+			Data:   listing,
+		},
+	}
+
+	return page.PrintAsHTML(w, "listing")
+}
+
+func (i Info) loadDirectoryContents(file http.File, c *config.Config) (*Listing, error) {
+	files, err := file.Readdir(-1)
+	if err != nil {
+		return nil, err
+	}
+
+	listing := directoryListing(files, i.RootPath)
+	return &listing, nil
+}
+
+func directoryListing(files []os.FileInfo, urlPath string) Listing {
+	var (
+		fileinfos           []Info
+		dirCount, fileCount int
+	)
+
+	for _, f := range files {
+		name := f.Name()
+
+		if f.IsDir() {
+			name += "/"
+			dirCount++
+		} else {
+			fileCount++
+		}
+
+		url := url.URL{Path: "./" + name} // prepend with "./" to fix paths with ':' in the name
+
+		fileinfos = append(fileinfos, Info{
+			IsDir:   f.IsDir(),
+			Name:    f.Name(),
+			Size:    f.Size(),
+			URL:     url.String(),
+			ModTime: f.ModTime().UTC(),
+			Mode:    f.Mode(),
+		})
+	}
+
+	return Listing{
+		Name:     path.Base(urlPath),
+		Path:     urlPath,
+		Items:    fileinfos,
+		NumDirs:  dirCount,
+		NumFiles: fileCount,
+	}
+}
+
+// ServeRawFile serves raw files
+func (i *Info) ServeRawFile(w http.ResponseWriter, r *http.Request, c *config.Config) (int, error) {
+	err := i.GetExtendedInfo()
+	if err != nil {
+		return errors.ToHTTPCode(err), err
+	}
+
+	if i.Type != "text" {
+		i.Read()
+	}
+
+	w.Header().Set("Content-Type", i.Mimetype)
+	w.Write([]byte(i.Content))
+	return 200, nil
+}
+
+// SimplifyMimeType returns the base type of a file
+func SimplifyMimeType(name string) string {
+	if strings.HasPrefix(name, "video") {
+		return "video"
+	}
+
+	if strings.HasPrefix(name, "audio") {
+		return "audio"
+	}
+
+	if strings.HasPrefix(name, "image") {
+		return "image"
+	}
+
+	if strings.HasPrefix(name, "text") {
+		return "text"
+	}
+
+	if strings.HasPrefix(name, "application/javascript") {
+		return "text"
+	}
+
+	return "blob"
+}

directory/listing.go

@@ -0,0 +1,141 @@
+package directory
+
+import (
+	"net/http"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+)
+
+// A Listing is the context used to fill out a template.
+type Listing struct {
+	// The name of the directory (the last element of the path)
+	Name string
+	// The full path of the request
+	Path string
+	// The items (files and folders) in the path
+	Items []Info
+	// The number of directories in the listing
+	NumDirs int
+	// The number of files (items that aren't directories) in the listing
+	NumFiles int
+	// Which sorting order is used
+	Sort string
+	// And which order
+	Order string
+	// If ≠0 then Items have been limited to that many elements
+	ItemsLimitedTo int
+	httpserver.Context
+}
+
+// handleSortOrder gets and stores for a Listing the 'sort' and 'order',
+// and reads 'limit' if given. The latter is 0 if not given. Sets cookies.
+func handleSortOrder(w http.ResponseWriter, r *http.Request, scope string) (sort string, order string, limit int, err error) {
+	sort, order, limitQuery := r.URL.Query().Get("sort"), r.URL.Query().Get("order"), r.URL.Query().Get("limit")
+
+	// If the query 'sort' or 'order' is empty, use defaults or any values previously saved in Cookies
+	switch sort {
+	case "":
+		sort = "name"
+		if sortCookie, sortErr := r.Cookie("sort"); sortErr == nil {
+			sort = sortCookie.Value
+		}
+	case "name", "size", "type":
+		http.SetCookie(w, &http.Cookie{Name: "sort", Value: sort, Path: scope, Secure: r.TLS != nil})
+	}
+
+	switch order {
+	case "":
+		order = "asc"
+		if orderCookie, orderErr := r.Cookie("order"); orderErr == nil {
+			order = orderCookie.Value
+		}
+	case "asc", "desc":
+		http.SetCookie(w, &http.Cookie{Name: "order", Value: order, Path: scope, Secure: r.TLS != nil})
+	}
+
+	if limitQuery != "" {
+		limit, err = strconv.Atoi(limitQuery)
+		if err != nil { // if the 'limit' query can't be interpreted as a number, return err
+			return
+		}
+	}
+
+	return
+}
+
+// Implement sorting for Listing
+type byName Listing
+type bySize Listing
+type byTime Listing
+
+// By Name
+func (l byName) Len() int      { return len(l.Items) }
+func (l byName) Swap(i, j int) { l.Items[i], l.Items[j] = l.Items[j], l.Items[i] }
+
+// Treat upper and lower case equally
+func (l byName) Less(i, j int) bool {
+	if l.Items[i].IsDir && !l.Items[j].IsDir {
+		return true
+	}
+
+	if !l.Items[i].IsDir && l.Items[j].IsDir {
+		return false
+	}
+
+	return strings.ToLower(l.Items[i].Name) < strings.ToLower(l.Items[j].Name)
+}
+
+// By Size
+func (l bySize) Len() int      { return len(l.Items) }
+func (l bySize) Swap(i, j int) { l.Items[i], l.Items[j] = l.Items[j], l.Items[i] }
+
+const directoryOffset = -1 << 31 // = math.MinInt32
+func (l bySize) Less(i, j int) bool {
+	iSize, jSize := l.Items[i].Size, l.Items[j].Size
+	if l.Items[i].IsDir {
+		iSize = directoryOffset + iSize
+	}
+	if l.Items[j].IsDir {
+		jSize = directoryOffset + jSize
+	}
+	return iSize < jSize
+}
+
+// By Time
+func (l byTime) Len() int           { return len(l.Items) }
+func (l byTime) Swap(i, j int)      { l.Items[i], l.Items[j] = l.Items[j], l.Items[i] }
+func (l byTime) Less(i, j int) bool { return l.Items[i].ModTime.Before(l.Items[j].ModTime) }
+
+// Add sorting method to "Listing"
+// it will apply what's in ".Sort" and ".Order"
+func (l Listing) applySort() {
+	// Check '.Order' to know how to sort
+	if l.Order == "desc" {
+		switch l.Sort {
+		case "name":
+			sort.Sort(sort.Reverse(byName(l)))
+		case "size":
+			sort.Sort(sort.Reverse(bySize(l)))
+		case "time":
+			sort.Sort(sort.Reverse(byTime(l)))
+		default:
+			// If not one of the above, do nothing
+			return
+		}
+	} else { // If we had more Orderings we could add them here
+		switch l.Sort {
+		case "name":
+			sort.Sort(byName(l))
+		case "size":
+			sort.Sort(bySize(l))
+		case "time":
+			sort.Sort(byTime(l))
+		default:
+			sort.Sort(byName(l))
+			return
+		}
+	}
+}

directory/update.go

@@ -0,0 +1,130 @@
+package directory
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"io/ioutil"
+	"net/http"
+	"path/filepath"
+	"strings"
+
+	"github.com/hacdias/caddy-filemanager/config"
+	"github.com/spf13/hugo/parser"
+)
+
+// Update is used to update a file that was edited
+func (i *Info) Update(w http.ResponseWriter, r *http.Request, c *config.Config) (int, error) {
+	var data map[string]interface{}
+	kind := r.Header.Get("kind")
+
+	if kind == "" {
+		return http.StatusBadRequest, nil
+	}
+
+	// Get the JSON information
+	rawBuffer := new(bytes.Buffer)
+	rawBuffer.ReadFrom(r.Body)
+	err := json.Unmarshal(rawBuffer.Bytes(), &data)
+
+	if err != nil {
+		return http.StatusInternalServerError, err
+	}
+
+	var file []byte
+	var code int
+
+	switch kind {
+	case "frontmatter-only":
+		if file, code, err = parseFrontMatterOnlyFile(data, i.Name); err != nil {
+			return http.StatusInternalServerError, err
+		}
+	case "content-only":
+		mainContent := data["content"].(string)
+		mainContent = strings.TrimSpace(mainContent)
+		file = []byte(mainContent)
+	case "complete":
+		if file, code, err = parseCompleteFile(data, i.Name); err != nil {
+			return http.StatusInternalServerError, err
+		}
+	default:
+		return http.StatusBadRequest, nil
+	}
+
+	// Write the file
+	err = ioutil.WriteFile(i.Path, file, 0666)
+
+	if err != nil {
+		return http.StatusInternalServerError, err
+	}
+
+	return code, nil
+}
+
+func parseFrontMatterOnlyFile(data interface{}, filename string) ([]byte, int, error) {
+	frontmatter := strings.TrimPrefix(filepath.Ext(filename), ".")
+	var mark rune
+
+	switch frontmatter {
+	case "toml":
+		mark = rune('+')
+	case "json":
+		mark = rune('{')
+	case "yaml":
+		mark = rune('-')
+	default:
+		return []byte{}, http.StatusBadRequest, errors.New("Can't define the frontmatter.")
+	}
+
+	f, err := parser.InterfaceToFrontMatter(data, mark)
+	fString := string(f)
+
+	// If it's toml or yaml, strip frontmatter identifier
+	if frontmatter == "toml" {
+		fString = strings.TrimSuffix(fString, "+++\n")
+		fString = strings.TrimPrefix(fString, "+++\n")
+	}
+
+	if frontmatter == "yaml" {
+		fString = strings.TrimSuffix(fString, "---\n")
+		fString = strings.TrimPrefix(fString, "---\n")
+	}
+
+	f = []byte(fString)
+
+	if err != nil {
+		return []byte{}, http.StatusInternalServerError, err
+	}
+
+	return f, http.StatusOK, nil
+}
+
+func parseCompleteFile(data map[string]interface{}, filename string) ([]byte, int, error) {
+	// The main content of the file
+	mainContent := data["content"].(string)
+	mainContent = "\n\n" + strings.TrimSpace(mainContent) + "\n"
+
+	// Removes the main content from the rest of the frontmatter
+	delete(data, "content")
+
+	if _, ok := data["date"]; ok {
+		data["date"] = data["date"].(string) + ":00"
+	}
+
+	// Converts the frontmatter in JSON
+	jsonFrontmatter, err := json.Marshal(data)
+
+	if err != nil {
+		return []byte{}, http.StatusInternalServerError, err
+	}
+
+	// Indents the json
+	frontMatterBuffer := new(bytes.Buffer)
+	json.Indent(frontMatterBuffer, jsonFrontmatter, "", "  ")
+
+	// Generates the final file
+	f := new(bytes.Buffer)
+	f.Write(frontMatterBuffer.Bytes())
+	f.Write([]byte(mainContent))
+	return f.Bytes(), http.StatusOK, nil
+}