clean

_stuff/tools/commands/commands.go

@@ -0,0 +1,15 @@
+package commands
+
+import (
+	"os"
+	"os/exec"
+)
+
+// Run executes an external command
+func Run(command string, args []string, path string) error {
+	cmd := exec.Command(command, args...)
+	cmd.Dir = path
+	cmd.Stdout = os.Stderr
+	cmd.Stderr = os.Stderr
+	return cmd.Run()
+}

_stuff/tools/frontmatter/frontmatter.go

@@ -0,0 +1,173 @@
+package frontmatter
+
+import (
+	"log"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/hacdias/caddy-hugo/tools/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
+}

_stuff/tools/installer/hashes.go

@@ -0,0 +1,25 @@
+package installer
+
+var (
+	sha256Hash = map[string]string{
+		"hugo_0.16_darwin-arm32.tgz":    "683d5d4b4e0ac03a183ca5eb9019981ba696569445c7d6d1efc7e6706bd273a5",
+		"hugo_0.16_dragonfly-64bit.tgz": "63a3ee9a36d4d2166c77b96bb8bf39b2239affe118e44a83b3d0a44374a8921d",
+		"hugo_0.16_freebsd-32bit.tgz":   "ea3f84900feeeb9d89573dea49a4349753116e70de561eeec4858f7ffc74f8f9",
+		"hugo_0.16_freebsd-64bit.tgz":   "8d9320bb660090a77a4f922ca30b1582593bc6d87c3fd8bd6f5ecbe49cf1d2f2",
+		"hugo_0.16_freebsd-arm32.tgz":   "b4c21296e01ea68709ac50d7eb1d314b738f1c8408ff2be223d06ae76604dbea",
+		"hugo_0.16_linux-32bit.tgz":     "aed82d156f01a4562c39bd1af41aa81699009140da965e0369c370ba874725c9",
+		"hugo_0.16_linux-64bit.tgz":     "13e299dc45bea4fad5bdf8c2640305a5926e2acd02c3aa03b7864403e513920e",
+		"hugo_0.16_linux-arm32.tgz":     "bc836def127d93e2457da9994f9c09b0100523e46d61074cd724ef092b11714f",
+		"hugo_0.16_linux-arm64.tgz":     "d04486918f43f89f1e0359eebedd8a05d96f7ca40f93e7fd8d7c3f2dac115a8d",
+		"hugo_0.16_netbsd-32bit.tgz":    "cb578eebec5b6364b0afd5bb208d94317acab0a3e033b81f04b1511af0669b63",
+		"hugo_0.16_netbsd-64bit.tgz":    "d3c766d9800d7fdd268ffd2f28b7af451f13a4de63901bfdae2ee5c96528b8cc",
+		"hugo_0.16_netbsd-arm32.tgz":    "51162b2637e71b786582af715a44b778f62bdc62a9a354ccc4a7c8384afe194c",
+		"hugo_0.16_openbsd-32bit.tgz":   "2d1e112a7346850897ea77da868c0d987ef90efb7f49c917659437a5a67f89f8",
+		"hugo_0.16_openbsd-64bit.tgz":   "7b33ff2565df5a6253c3e4308813d947e34af04c633fb4e01cac83751066e16e",
+		"hugo_0.16_osx-32bit.tgz":       "6155dda548bbd1e26c26a4a00472e4c0e55fad9fcd46991ce90987385bd5fd0a",
+		"hugo_0.16_osx-64bit.tgz":       "b0cba8f6996946ef34a664184d6461567d79fc2a3e793145d34379902eda0ad9",
+		"hugo_0.16_solaris-64bit.tgz":   "af9557403af5e16eb7faf965c04540417a70699efbbbc4e0a7ae4c4703ad1ae8",
+		"hugo_0.16_windows-32bit.zip":   "1c72d06843fe02cb62348660d87a523c885ed684a683271fc8762e7234c4210b",
+		"hugo_0.16_windows-64bit.zip":   "a3fda0bd30592e4eb3bdde85c8a8ce23a7433073536466d16fd0e97bf7794067",
+	}
+)

_stuff/tools/installer/installer.go

@@ -0,0 +1,216 @@
+package installer
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+
+	"github.com/hacdias/caddy-hugo/tools/files"
+	"github.com/mitchellh/go-homedir"
+	"github.com/pivotal-golang/archiver/extractor"
+)
+
+const (
+	version = "0.16"
+	baseurl = "https://github.com/spf13/hugo/releases/download/v" + version + "/"
+)
+
+var caddy, bin, temp, hugo, tempfile, zipname, exename string
+
+// GetPath retrives the Hugo path for the user or install it if it's not found
+func GetPath() string {
+	initializeVariables()
+
+	var err error
+
+	// Check if Hugo is already on $PATH
+	if hugo, err = exec.LookPath("hugo"); err == nil {
+		if checkVersion() {
+			return hugo
+		}
+	}
+
+	// Check if Hugo is on $HOME/.caddy/bin
+	if _, err = os.Stat(hugo); err == nil {
+		if checkVersion() {
+			return hugo
+		}
+	}
+
+	fmt.Println("Unable to find Hugo on your computer.")
+
+	// Create the neccessary folders
+	os.MkdirAll(caddy, 0774)
+	os.Mkdir(bin, 0774)
+
+	if temp, err = ioutil.TempDir("", "caddy-hugo"); err != nil {
+		fmt.Println(err)
+		os.Exit(-1)
+	}
+
+	downloadHugo()
+	checkSHA256()
+
+	fmt.Print("Unzipping... ")
+
+	// Unzip or Ungzip the file
+	switch runtime.GOOS {
+	case "darwin", "windows":
+		zp := extractor.NewZip()
+		err = zp.Extract(tempfile, temp)
+	default:
+		gz := extractor.NewTgz()
+		err = gz.Extract(tempfile, temp)
+	}
+
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(-1)
+	}
+
+	fmt.Println("done.")
+
+	var exetorename string
+
+	err = filepath.Walk(temp, func(path string, f os.FileInfo, err error) error {
+		if f.Name() == exename {
+			exetorename = path
+		}
+
+		return nil
+	})
+
+	// Copy the file
+	fmt.Print("Moving Hugo executable... ")
+	err = files.CopyFile(exetorename, hugo)
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(-1)
+	}
+
+	err = os.Chmod(hugo, 0755)
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(-1)
+	}
+
+	fmt.Println("done.")
+	fmt.Println("Hugo installed at " + hugo)
+	defer os.RemoveAll(temp)
+	return hugo
+}
+
+func initializeVariables() {
+	var arch string
+	switch runtime.GOARCH {
+	case "amd64":
+		arch = "64bit"
+	case "386":
+		arch = "32bit"
+	case "arm":
+		arch = "arm32"
+	default:
+		arch = runtime.GOARCH
+	}
+
+	var ops = runtime.GOOS
+	if runtime.GOOS == "darwin" && runtime.GOARCH != "arm" {
+		ops = "osx"
+	}
+
+	exename = "hugo"
+	zipname = "hugo_" + version + "_" + ops + "-" + arch
+
+	homedir, err := homedir.Dir()
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(-1)
+	}
+
+	caddy = filepath.Join(homedir, ".caddy")
+	bin = filepath.Join(caddy, "bin")
+	hugo = filepath.Join(bin, "hugo")
+
+	switch runtime.GOOS {
+	case "windows":
+		zipname += ".zip"
+		exename += ".exe"
+		hugo += ".exe"
+	default:
+		zipname += ".tgz"
+	}
+}
+
+func checkVersion() bool {
+	out, _ := exec.Command("hugo", "version").Output()
+
+	r := regexp.MustCompile(`v\d\.\d{2}`)
+	v := r.FindStringSubmatch(string(out))[0]
+	v = v[1:len(v)]
+
+	return (v == version)
+}
+
+func downloadHugo() {
+	tempfile = filepath.Join(temp, zipname)
+
+	fmt.Print("Downloading Hugo from GitHub releases... ")
+
+	// Create the file
+	out, err := os.Create(tempfile)
+	out.Chmod(0774)
+	if err != nil {
+		defer os.RemoveAll(temp)
+		fmt.Println(err)
+		os.Exit(-1)
+	}
+	defer out.Close()
+
+	// Get the data
+	resp, err := http.Get(baseurl + zipname)
+	if err != nil {
+		fmt.Println("An error ocurred while downloading. If this error persists, try downloading Hugo from \"https://github.com/spf13/hugo/releases/\" and put the executable in " + bin + " and rename it to 'hugo' or 'hugo.exe' if you're on Windows.")
+		fmt.Println(err)
+		os.Exit(-1)
+	}
+	defer resp.Body.Close()
+
+	// Writer the body to file
+	_, err = io.Copy(out, resp.Body)
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(-1)
+	}
+
+	fmt.Println("downloaded.")
+}
+
+func checkSHA256() {
+	fmt.Print("Checking SHA256...")
+
+	hasher := sha256.New()
+	f, err := os.Open(tempfile)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer f.Close()
+	if _, err := io.Copy(hasher, f); err != nil {
+		log.Fatal(err)
+	}
+
+	if hex.EncodeToString(hasher.Sum(nil)) != sha256Hash[zipname] {
+		fmt.Println("can't verify SHA256.")
+		os.Exit(-1)
+	}
+
+	fmt.Println("checked!")
+}

_stuff/tools/server/response.go

@@ -0,0 +1,30 @@
+package server
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+type Response struct {
+	Code    int
+	Err     error
+	Content interface{}
+}
+
+// RespondJSON used to send JSON responses to the web server
+func RespondJSON(w http.ResponseWriter, r *Response) (int, error) {
+	if r.Content == nil {
+		r.Content = map[string]string{}
+	}
+
+	msg, msgErr := json.Marshal(r.Content)
+
+	if msgErr != nil {
+		return 500, msgErr
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(r.Code)
+	w.Write(msg)
+	return 0, r.Err
+}

_stuff/tools/server/url.go

@@ -0,0 +1,26 @@
+package server
+
+import (
+	"net/http"
+	"strings"
+)
+
+// ParseURLComponents parses the components of an URL creating an array
+func ParseURLComponents(r *http.Request) []string {
+	//The URL that the user queried.
+	path := r.URL.Path
+	path = strings.TrimSpace(path)
+	//Cut off the leading and trailing forward slashes, if they exist.
+	//This cuts off the leading forward slash.
+	if strings.HasPrefix(path, "/") {
+		path = path[1:]
+	}
+	//This cuts off the trailing forward slash.
+	if strings.HasSuffix(path, "/") {
+		cutOffLastCharLen := len(path) - 1
+		path = path[:cutOffLastCharLen]
+	}
+	//We need to isolate the individual components of the path.
+	components := strings.Split(path, "/")
+	return components
+}

_stuff/tools/templates/templates.go

@@ -0,0 +1,73 @@
+package templates
+
+import (
+	"log"
+	"net/http"
+	"strings"
+	"text/template"
+
+	"github.com/hacdias/caddy-hugo/routes/assets"
+)
+
+// 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
+}
+
+// Get is used to get a ready to use template based on the url and on
+// other sent templates
+func Get(r *http.Request, functions template.FuncMap, templates ...string) (*template.Template, error) {
+	// If this is a pjax request, use the minimal template to send only
+	// the main content
+	if r.Header.Get("X-PJAX") == "true" {
+		templates = append(templates, "base_minimal")
+	} else {
+		templates = append(templates, "base_full")
+	}
+
+	var tpl *template.Template
+
+	// For each template, add it to the the tpl variable
+	for i, t := range templates {
+		// Get the template from the assets
+		page, err := assets.Asset("templates/" + t + ".tmpl")
+
+		// Check if there is some error. If so, the template doesn't exist
+		if err != nil {
+			log.Print(err)
+			return new(template.Template), err
+		}
+
+		// If it's the first iteration, creates a new template and add the
+		// functions map
+		if i == 0 {
+			tpl, err = template.New(t).Funcs(functions).Parse(string(page))
+		} else {
+			tpl, err = tpl.Parse(string(page))
+		}
+
+		if err != nil {
+			log.Print(err)
+			return new(template.Template), err
+		}
+	}
+
+	return tpl, nil
+}

_stuff/tools/templates/templates_test.go

@@ -0,0 +1,39 @@
+package templates
+
+import "testing"
+
+type canBeEdited struct {
+	file   string
+	result bool
+}
+
+var canBeEditedPairs = []canBeEdited{
+	{"file.markdown", true},
+	{"file.md", true},
+	{"file.json", true},
+	{"file.toml", true},
+	{"file.yaml", true},
+	{"file.css", true},
+	{"file.sass", true},
+	{"file.scss", true},
+	{"file.js", true},
+	{"file.html", true},
+	{"file.git", false},
+	{"file.log", false},
+	{"file.sh", false},
+	{"file.png", false},
+	{"file.jpg", false},
+}
+
+func TestCanBeEdited(t *testing.T) {
+	for _, pair := range canBeEditedPairs {
+		v := CanBeEdited(pair.file)
+		if v != pair.result {
+			t.Error(
+				"For", pair.file,
+				"expected", pair.result,
+				"got", v,
+			)
+		}
+	}
+}

_stuff/tools/variables/strings.go

@@ -0,0 +1,10 @@
+package variables
+
+func StringInSlice(a string, list []string) (bool, int) {
+	for i, b := range list {
+		if b == a {
+			return true, i
+		}
+	}
+	return false, 0
+}

_stuff/tools/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
+}

_stuff/tools/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,
+			)
+		}
+	}
+}

_stuff/tools/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
+}

_stuff/tools/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
+}

_stuff/tools/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,
+			)
+		}
+	}
+}