+ {{ end }}
+
+{{ end }}
+{{ end }}
+{{ end }}
diff --git a/binary.go b/binary.go
index 437018ce..ec585562 100644
--- a/binary.go
+++ b/binary.go
@@ -4,6 +4,8 @@
// assets/public/js/application.js
// assets/templates/actions.tmpl
// assets/templates/base.tmpl
+// assets/templates/editor.tmpl
+// assets/templates/frontmatter.tmpl
// assets/templates/listing.tmpl
// assets/templates/single.tmpl
// DO NOT EDIT!
@@ -104,6 +106,42 @@ func templatesBaseTmpl() (*asset, error) {
return a, err
}
+// templatesEditorTmpl reads file data from disk. It returns an error on failure.
+func templatesEditorTmpl() (*asset, error) {
+ path := "D:\\Code\\Go\\src\\github.com\\hacdias\\caddy-filemanager\\assets\\templates\\editor.tmpl"
+ name := "templates/editor.tmpl"
+ bytes, err := bindataRead(path, name)
+ if err != nil {
+ return nil, err
+ }
+
+ fi, err := os.Stat(path)
+ if err != nil {
+ err = fmt.Errorf("Error reading asset info %s at %s: %v", name, path, err)
+ }
+
+ a := &asset{bytes: bytes, info: fi}
+ return a, err
+}
+
+// templatesFrontmatterTmpl reads file data from disk. It returns an error on failure.
+func templatesFrontmatterTmpl() (*asset, error) {
+ path := "D:\\Code\\Go\\src\\github.com\\hacdias\\caddy-filemanager\\assets\\templates\\frontmatter.tmpl"
+ name := "templates/frontmatter.tmpl"
+ bytes, err := bindataRead(path, name)
+ if err != nil {
+ return nil, err
+ }
+
+ fi, err := os.Stat(path)
+ if err != nil {
+ err = fmt.Errorf("Error reading asset info %s at %s: %v", name, path, err)
+ }
+
+ a := &asset{bytes: bytes, info: fi}
+ return a, err
+}
+
// templatesListingTmpl reads file data from disk. It returns an error on failure.
func templatesListingTmpl() (*asset, error) {
path := "D:\\Code\\Go\\src\\github.com\\hacdias\\caddy-filemanager\\assets\\templates\\listing.tmpl"
@@ -196,6 +234,8 @@ var _bindata = map[string]func() (*asset, error){
"public/js/application.js": publicJsApplicationJs,
"templates/actions.tmpl": templatesActionsTmpl,
"templates/base.tmpl": templatesBaseTmpl,
+ "templates/editor.tmpl": templatesEditorTmpl,
+ "templates/frontmatter.tmpl": templatesFrontmatterTmpl,
"templates/listing.tmpl": templatesListingTmpl,
"templates/single.tmpl": templatesSingleTmpl,
}
@@ -251,6 +291,8 @@ var _bintree = &bintree{nil, map[string]*bintree{
"templates": &bintree{nil, map[string]*bintree{
"actions.tmpl": &bintree{templatesActionsTmpl, map[string]*bintree{}},
"base.tmpl": &bintree{templatesBaseTmpl, map[string]*bintree{}},
+ "editor.tmpl": &bintree{templatesEditorTmpl, map[string]*bintree{}},
+ "frontmatter.tmpl": &bintree{templatesFrontmatterTmpl, map[string]*bintree{}},
"listing.tmpl": &bintree{templatesListingTmpl, map[string]*bintree{}},
"single.tmpl": &bintree{templatesSingleTmpl, map[string]*bintree{}},
}},
diff --git a/editor.go b/editor.go
new file mode 100644
index 00000000..b2fef581
--- /dev/null
+++ b/editor.go
@@ -0,0 +1,124 @@
+package filemanager
+
+import (
+ "bytes"
+ "path/filepath"
+ "strings"
+
+ "github.com/spf13/hugo/parser"
+)
+
+// Editor contains the information for the editor page
+type Editor struct {
+ Class string
+ Mode string
+ Content string
+ FrontMatter interface{}
+}
+
+// GetEditor gets the editor based on a FileInfo struct
+func (fi FileInfo) GetEditor() (*Editor, error) {
+ // Create a new editor variable and set the mode
+ editor := new(Editor)
+ editor.Mode = strings.TrimPrefix(filepath.Ext(fi.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(fi.Raw) {
+ // Starts a new buffer and parses the file using Hugo's functions
+ buffer := bytes.NewBuffer(fi.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 = Pretty(page.FrontMatter())
+ editor.Class = "complete"
+ } else {
+ // The editor will handle only content
+ editor.Class = "content-only"
+ editor.Content = fi.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(fi.Raw) {
+ editor.FrontMatter, _, err = Pretty(fi.Raw)
+ } else {
+ editor.FrontMatter, _, err = Pretty(editor.appendFrontMatterRune(fi.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 = fi.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
+}
diff --git a/fileinfo.go b/fileinfo.go
index 4d78c947..728ad60b 100644
--- a/fileinfo.go
+++ b/fileinfo.go
@@ -27,6 +27,7 @@ type FileInfo struct {
Mode os.FileMode
Mimetype string
Content string
+ Raw []byte
Type string
}
@@ -85,6 +86,7 @@ func (fi *FileInfo) Read() error {
}
fi.Mimetype = http.DetectContentType(raw)
fi.Content = string(raw)
+ fi.Raw = raw
return nil
}
@@ -164,6 +166,17 @@ func (fi *FileInfo) serveSingleFile(w http.ResponseWriter, r *http.Request, c *C
},
}
+ if CanBeEdited(fi.Name) {
+ editor, err := fi.GetEditor()
+
+ if err != nil {
+ return http.StatusInternalServerError, err
+ }
+
+ page.Info.Data = editor
+ return page.PrintAsHTML(w, "frontmatter", "editor")
+ }
+
return page.PrintAsHTML(w, "single")
}
diff --git a/frontmatter.go b/frontmatter.go
new file mode 100644
index 00000000..25aae8be
--- /dev/null
+++ b/frontmatter.go
@@ -0,0 +1,173 @@
+package filemanager
+
+import (
+ "log"
+ "reflect"
+ "sort"
+ "strings"
+
+ "github.com/hacdias/caddy-filemanager/variables"
+ "github.com/spf13/cast"
+ "github.com/spf13/hugo/parser"
+)
+
+const (
+ mainName = "#MAIN#"
+ objectType = "object"
+ arrayType = "array"
+)
+
+var mainTitle = ""
+
+// Pretty creates a new FrontMatter object
+func Pretty(content []byte) (interface{}, string, error) {
+ frontType := parser.DetectFrontMatter(rune(content[0]))
+ front, err := frontType.Parse(content)
+
+ if err != nil {
+ return []string{}, mainTitle, err
+ }
+
+ object := new(frontmatter)
+ object.Type = objectType
+ object.Name = mainName
+
+ return rawToPretty(front, object), mainTitle, nil
+}
+
+type frontmatter struct {
+ Name string
+ Title string
+ Content interface{}
+ Type string
+ HTMLType string
+ Parent *frontmatter
+}
+
+func rawToPretty(config interface{}, parent *frontmatter) interface{} {
+ objects := []*frontmatter{}
+ arrays := []*frontmatter{}
+ fields := []*frontmatter{}
+
+ cnf := map[string]interface{}{}
+
+ if reflect.TypeOf(config) == reflect.TypeOf(map[interface{}]interface{}{}) {
+ for key, value := range config.(map[interface{}]interface{}) {
+ cnf[key.(string)] = value
+ }
+ } else if reflect.TypeOf(config) == reflect.TypeOf([]interface{}{}) {
+ for key, value := range config.([]interface{}) {
+ cnf[string(key)] = value
+ }
+ } else {
+ cnf = config.(map[string]interface{})
+ }
+
+ for name, element := range cnf {
+ if variables.IsMap(element) {
+ objects = append(objects, handleObjects(element, parent, name))
+ } else if variables.IsSlice(element) {
+ arrays = append(arrays, handleArrays(element, parent, name))
+ } else {
+ if name == "title" && parent.Name == mainName {
+ mainTitle = element.(string)
+ }
+
+ fields = append(fields, handleFlatValues(element, parent, name))
+ }
+ }
+
+ sort.Sort(sortByTitle(objects))
+ sort.Sort(sortByTitle(arrays))
+ sort.Sort(sortByTitle(fields))
+
+ settings := []*frontmatter{}
+ settings = append(settings, fields...)
+ settings = append(settings, arrays...)
+ settings = append(settings, objects...)
+ return settings
+}
+
+type sortByTitle []*frontmatter
+
+func (f sortByTitle) Len() int { return len(f) }
+func (f sortByTitle) Swap(i, j int) { f[i], f[j] = f[j], f[i] }
+func (f sortByTitle) Less(i, j int) bool {
+ return strings.ToLower(f[i].Name) < strings.ToLower(f[j].Name)
+}
+
+func handleObjects(content interface{}, parent *frontmatter, name string) *frontmatter {
+ c := new(frontmatter)
+ c.Parent = parent
+ c.Type = objectType
+ c.Title = name
+
+ if parent.Name == mainName {
+ c.Name = c.Title
+ } else if parent.Type == arrayType {
+ c.Name = parent.Name + "[]"
+ } else {
+ c.Name = parent.Name + "[" + c.Title + "]"
+ }
+
+ c.Content = rawToPretty(content, c)
+ return c
+}
+
+func handleArrays(content interface{}, parent *frontmatter, name string) *frontmatter {
+ c := new(frontmatter)
+ c.Parent = parent
+ c.Type = arrayType
+ c.Title = name
+
+ if parent.Name == mainName {
+ c.Name = name
+ } else {
+ c.Name = parent.Name + "[" + name + "]"
+ }
+
+ c.Content = rawToPretty(content, c)
+ return c
+}
+
+func handleFlatValues(content interface{}, parent *frontmatter, name string) *frontmatter {
+ c := new(frontmatter)
+ c.Parent = parent
+
+ switch reflect.ValueOf(content).Kind() {
+ case reflect.Bool:
+ c.Type = "boolean"
+ case reflect.Int, reflect.Float32, reflect.Float64:
+ c.Type = "number"
+ default:
+ c.Type = "string"
+ }
+
+ c.Content = content
+
+ switch strings.ToLower(name) {
+ case "description":
+ c.HTMLType = "textarea"
+ case "date", "publishdate":
+ c.HTMLType = "datetime"
+ c.Content = cast.ToTime(content)
+ default:
+ c.HTMLType = "text"
+ }
+
+ if parent.Type == arrayType {
+ c.Name = parent.Name + "[]"
+ c.Title = content.(string)
+ } else if parent.Type == objectType {
+ c.Title = name
+ c.Name = parent.Name + "[" + name + "]"
+
+ if parent.Name == mainName {
+ c.Name = name
+ }
+ } else {
+ log.Panic("Parent type not allowed in handleFlatValues.")
+ }
+
+ return c
+}
diff --git a/page.go b/page.go
index dcf0ebbe..ad931adf 100644
--- a/page.go
+++ b/page.go
@@ -7,6 +7,8 @@ import (
"log"
"net/http"
"strings"
+
+ "github.com/hacdias/caddy-filemanager/variables"
)
// Page contains the informations and functions needed to show the page
@@ -73,6 +75,13 @@ func (p PageInfo) PreviousLink() string {
// PrintAsHTML formats the page in HTML and executes the template
func (p Page) PrintAsHTML(w http.ResponseWriter, templates ...string) (int, error) {
+ // Create the functions map, then the template, check for erros and
+ // execute the template if there aren't errors
+ functions := template.FuncMap{
+ "SplitCapitalize": variables.SplitCapitalize,
+ "Defined": variables.Defined,
+ }
+
templates = append(templates, "actions", "base")
var tpl *template.Template
@@ -90,7 +99,7 @@ func (p Page) PrintAsHTML(w http.ResponseWriter, templates ...string) (int, erro
// If it's the first iteration, creates a new template and add the
// functions map
if i == 0 {
- tpl, err = template.New(t).Parse(string(page))
+ tpl, err = template.New(t).Funcs(functions).Parse(string(page))
} else {
tpl, err = tpl.Parse(string(page))
}
diff --git a/variables/transform.go b/variables/transform.go
new file mode 100644
index 00000000..3307b7a3
--- /dev/null
+++ b/variables/transform.go
@@ -0,0 +1,42 @@
+package variables
+
+import (
+ "strings"
+ "unicode"
+)
+
+var splitCapitalizeExceptions = map[string]string{
+ "youtube": "YouTube",
+ "github": "GitHub",
+ "googleplus": "Google Plus",
+ "linkedin": "LinkedIn",
+}
+
+// SplitCapitalize splits a string by its uppercase letters and capitalize the
+// first letter of the string
+func SplitCapitalize(name string) string {
+ if val, ok := splitCapitalizeExceptions[strings.ToLower(name)]; ok {
+ return val
+ }
+
+ var words []string
+ l := 0
+ for s := name; s != ""; s = s[l:] {
+ l = strings.IndexFunc(s[1:], unicode.IsUpper) + 1
+ if l <= 0 {
+ l = len(s)
+ }
+ words = append(words, s[:l])
+ }
+
+ name = ""
+
+ for _, element := range words {
+ name += element + " "
+ }
+
+ name = strings.ToLower(name[:len(name)-1])
+ name = strings.ToUpper(string(name[0])) + name[1:]
+
+ return name
+}
diff --git a/variables/transform_test.go b/variables/transform_test.go
new file mode 100644
index 00000000..1a0c2fbf
--- /dev/null
+++ b/variables/transform_test.go
@@ -0,0 +1,31 @@
+package variables
+
+import "testing"
+
+type testSplitCapitalize struct {
+ name string
+ result string
+}
+
+var testSplitCapitalizeCases = []testSplitCapitalize{
+ {"loremIpsum", "Lorem ipsum"},
+ {"LoremIpsum", "Lorem ipsum"},
+ {"loremipsum", "Loremipsum"},
+ {"YouTube", "YouTube"},
+ {"GitHub", "GitHub"},
+ {"GooglePlus", "Google Plus"},
+ {"Facebook", "Facebook"},
+}
+
+func TestSplitCapitalize(t *testing.T) {
+ for _, pair := range testSplitCapitalizeCases {
+ v := SplitCapitalize(pair.name)
+ if v != pair.result {
+ t.Error(
+ "For", pair.name,
+ "expected", pair.result,
+ "got", v,
+ )
+ }
+ }
+}
diff --git a/variables/types.go b/variables/types.go
new file mode 100644
index 00000000..ee43dad3
--- /dev/null
+++ b/variables/types.go
@@ -0,0 +1,13 @@
+package variables
+
+import "reflect"
+
+// IsMap checks if some variable is a map
+func IsMap(sth interface{}) bool {
+ return reflect.ValueOf(sth).Kind() == reflect.Map
+}
+
+// IsSlice checks if some variable is a slice
+func IsSlice(sth interface{}) bool {
+ return reflect.ValueOf(sth).Kind() == reflect.Slice
+}
diff --git a/variables/variables.go b/variables/variables.go
new file mode 100644
index 00000000..9d60dabf
--- /dev/null
+++ b/variables/variables.go
@@ -0,0 +1,37 @@
+package variables
+
+import (
+ "errors"
+ "log"
+ "reflect"
+)
+
+// Defined checks if variable is defined in a struct
+func Defined(data interface{}, field string) bool {
+ t := reflect.Indirect(reflect.ValueOf(data)).Type()
+
+ if t.Kind() != reflect.Struct {
+ log.Print("Non-struct type not allowed.")
+ return false
+ }
+
+ _, b := t.FieldByName(field)
+ return b
+}
+
+// Dict allows to send more than one variable into a template
+func Dict(values ...interface{}) (map[string]interface{}, error) {
+ if len(values)%2 != 0 {
+ return nil, errors.New("invalid dict call")
+ }
+ dict := make(map[string]interface{}, len(values)/2)
+ for i := 0; i < len(values); i += 2 {
+ key, ok := values[i].(string)
+ if !ok {
+ return nil, errors.New("dict keys must be strings")
+ }
+ dict[key] = values[i+1]
+ }
+
+ return dict, nil
+}
diff --git a/variables/variables_test.go b/variables/variables_test.go
new file mode 100644
index 00000000..ec76d459
--- /dev/null
+++ b/variables/variables_test.go
@@ -0,0 +1,41 @@
+package variables
+
+import "testing"
+
+type testDefinedData struct {
+ f1 string
+ f2 bool
+ f3 int
+ f4 func()
+}
+
+type testDefined struct {
+ data interface{}
+ field string
+ result bool
+}
+
+var testDefinedCases = []testDefined{
+ {testDefinedData{}, "f1", true},
+ {testDefinedData{}, "f2", true},
+ {testDefinedData{}, "f3", true},
+ {testDefinedData{}, "f4", true},
+ {testDefinedData{}, "f5", false},
+ {[]string{}, "", false},
+ {map[string]int{"oi": 4}, "", false},
+ {"asa", "", false},
+ {"int", "", false},
+}
+
+func TestDefined(t *testing.T) {
+ for _, pair := range testDefinedCases {
+ v := Defined(pair.data, pair.field)
+ if v != pair.result {
+ t.Error(
+ "For", pair.data,
+ "expected", pair.result,
+ "got", v,
+ )
+ }
+ }
+}