aadd first files based on caddy-filemanager

Former-commit-id: 20baeeb41a9555cefc3b31b495e24e907736c443

utils/errors.go

@@ -0,0 +1,24 @@
+package utils
+
+import (
+	"net/http"
+	"os"
+)
+
+// ErrorToHTTPCode converts errors to HTTP Status Code.
+func ErrorToHTTPCode(err error, gone bool) int {
+	switch {
+	case os.IsPermission(err):
+		return http.StatusForbidden
+	case os.IsNotExist(err):
+		if !gone {
+			return http.StatusNotFound
+		}
+
+		return http.StatusGone
+	case os.IsExist(err):
+		return http.StatusGone
+	default:
+		return http.StatusInternalServerError
+	}
+}

utils/types.go

@@ -0,0 +1,13 @@
+package utils
+
+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
+}

utils/types_test.go

@@ -0,0 +1,49 @@
+package utils
+
+import "testing"
+
+type interfaceToBool struct {
+	Value  interface{}
+	Result bool
+}
+
+var testIsMap = []*interfaceToBool{
+	&interfaceToBool{"teste", false},
+	&interfaceToBool{453478, false},
+	&interfaceToBool{-984512, false},
+	&interfaceToBool{true, false},
+	&interfaceToBool{map[string]bool{}, true},
+	&interfaceToBool{map[int]bool{}, true},
+	&interfaceToBool{map[interface{}]bool{}, true},
+	&interfaceToBool{[]string{}, false},
+}
+
+func TestIsMap(t *testing.T) {
+	for _, test := range testIsMap {
+		if IsMap(test.Value) != test.Result {
+			t.Errorf("Incorrect value on IsMap for %v; want: %v; got: %v", test.Value, test.Result, !test.Result)
+		}
+	}
+}
+
+var testIsSlice = []*interfaceToBool{
+	&interfaceToBool{"teste", false},
+	&interfaceToBool{453478, false},
+	&interfaceToBool{-984512, false},
+	&interfaceToBool{true, false},
+	&interfaceToBool{map[string]bool{}, false},
+	&interfaceToBool{map[int]bool{}, false},
+	&interfaceToBool{map[interface{}]bool{}, false},
+	&interfaceToBool{[]string{}, true},
+	&interfaceToBool{[]int{}, true},
+	&interfaceToBool{[]bool{}, true},
+	&interfaceToBool{[]interface{}{}, true},
+}
+
+func TestIsSlice(t *testing.T) {
+	for _, test := range testIsSlice {
+		if IsSlice(test.Value) != test.Result {
+			t.Errorf("Incorrect value on IsSlice for %v; want: %v; got: %v", test.Value, test.Result, !test.Result)
+		}
+	}
+}

utils/variables.go

@@ -0,0 +1,47 @@
+package utils
+
+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
+}
+
+// StringInSlice checks if a slice contains a string
+func StringInSlice(a string, list []string) (bool, int) {
+	for i, b := range list {
+		if b == a {
+			return true, i
+		}
+	}
+	return false, 0
+}

utils/variables_test.go

@@ -0,0 +1,41 @@
+package utils
+
+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,
+			)
+		}
+	}
+}