Relaxes error handling, added both forwarded and panic'd errors

ini.go

@@ -3,9 +3,10 @@ package ezconf
 import (
 	"errors"
 	"fmt"
-	"gopkg.in/ini.v1"
 	"os"
 	"strings"
+
+	"gopkg.in/ini.v1"
 )
 
 type Configuration struct {
@@ -13,20 +14,40 @@ type Configuration struct {
 	file         *ini.File
 }
 
-func NewConfiguration(fileLocation string) *Configuration {
+func CreateConfigurationFile(fileLocation string, defaultConfig string) error {
-	conf := new(Configuration)
+	err := createFile(fileLocation, []byte(defaultConfig))
-	conf.fileLocation = fileLocation
+	if err != nil {
-	conf.load()
+		return err
-	return conf
+	}
+	return nil
 }
 
-func (config *Configuration) GetSection(sectionName string) *ini.Section {
+func NewConfiguration(fileLocation string, defaultConfig string) (*Configuration, error) {
+	conf := new(Configuration)
+	conf.fileLocation = fileLocation
+	err := conf.createAndLoad(defaultConfig)
+	if err != nil {
+		return nil, err
+	}
+	return conf, nil
+}
+
+func LoadConfiguration(fileLocation string) (*Configuration, error) {
+	conf := new(Configuration)
+	conf.fileLocation = fileLocation
+	err := conf.load()
+	if err != nil {
+		return nil, err
+	}
+	return conf, nil
+}
+
+func (config *Configuration) GetSection(sectionName string) (*ini.Section, error) {
 	section, err := config.file.GetSection(sectionName)
 	if err != nil {
-		fmt.Printf("Error getting section %v in config: %v", sectionName, err)
+		return nil, err
-		os.Exit(1)
 	}
-	return section
+	return section, nil
 }
 
 func GetChildSection(section *ini.Section, childSectionName string) (childSection *ini.Section, err error) {
@@ -43,110 +64,362 @@ func GetChildSections(section *ini.Section) (childSections []*ini.Section) {
 	return section.ChildSections()
 }
 
-func (config *Configuration) GetKey(path string) *ini.Key {
+func CreateSection(path string, file *ini.File) error {
+	pathSplit := strings.Split(path, ".")
+	for i := 0; i < len(pathSplit)-1; i++ {
+		err := file.NewSections()
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (config *Configuration) GetKey(path string) (*ini.Key, error) {
 	splitPaths := strings.Split(path, ".")
 	if len(splitPaths) == 1 {
 		splitPaths = append([]string{"."}, splitPaths...)
 	}
 	sectionMask := strings.Join(splitPaths[0:len(splitPaths)-1], ".")
-	section := config.GetSection(sectionMask)
+	section, err := config.GetSection(sectionMask)
+	if err != nil {
+		return nil, err
+	}
 	keyName := splitPaths[len(splitPaths)-1]
 	key, err := section.GetKey(keyName)
 	if err != nil {
-		fmt.Printf("Error getting key %v: %v", keyName, err)
+		return nil, err
 	}
-	return key
+	return key, nil
-}
-
-func (config *Configuration) GetAsString(path string) string {
-	return config.GetKey(path).String()
 }
 
 func (config *Configuration) SetValue(path string, value string) {
-	config.GetKey(path).SetValue(value)
+	key, err := config.GetKey(path)
+	if err != nil {
+		err = nil
+		splitPath := strings.Split(path, ".")
+		err = config.file.NewSections(splitPath[0 : len(splitPath)-1]...)
+		if err != nil {
+			fmt.Printf("Error creating section %v in config: %v\n", path, err)
+			return
+		}
+	}
+	key, err = config.GetKey(path)
+	if err != nil {
+		fmt.Printf("Error getting path %v in config: %v\n", path, err)
+		return
+	}
+	key.SetValue(value)
+}
+
+func (config *Configuration) SetValueErr(path string, value string) error {
+	key, err := config.GetKey(path)
+	if err != nil {
+		err = nil
+		splitPath := strings.Split(path, ".")
+		err = config.file.NewSections(splitPath[0 : len(splitPath)-1]...)
+		if err != nil {
+			fmt.Printf("Error creating section %v in config: %v\n", path, err)
+			return err
+		}
+		fmt.Printf("New Val: Split Path: %v\n", splitPath)
+	}
+	key, err = config.GetKey(path)
+	if err != nil {
+		fmt.Printf("Error getting path %v in config: %v\n", path, err)
+		return err
+	}
+	key.SetValue(value)
+	return nil
+}
+
+func (config *Configuration) GetAsString(path string) string {
+	key, err := config.GetKey(path)
+	if err != nil {
+		fmt.Printf("Error getting path %v in config: %v\n", path, err)
+		return ""
+	}
+	return key.String()
+}
+
+func (config *Configuration) GetAsStringErr(path string) (string, error) {
+	key, err := config.GetKey(path)
+	if err != nil {
+		fmt.Printf("Error getting path %v in config: %v\n", path, err)
+		return "", nil
+	}
+	return key.String(), nil
 }
 
 func (config *Configuration) GetAsStrings(path string) []string {
-	return config.GetKey(path).Strings(",")
+	key, err := config.GetKey(path)
+	if err != nil {
+		fmt.Printf("Error getting path %v in config: %v\n", path, err)
+		return nil
+	}
+	return key.Strings(",")
+}
+
+func (config *Configuration) GetAsStringsErr(path string) ([]string, error) {
+	key, err := config.GetKey(path)
+	if err != nil {
+		fmt.Printf("Error getting path %v in config: %v\n", path, err)
+		return nil, err
+	}
+	return key.Strings(","), nil
 }
 
 func (config *Configuration) GetAsInt(path string) int {
 	var i int
-	var err error
+	key, err := config.GetKey(path)
-	i, err = config.GetKey(path).Int()
 	if err != nil {
-		fmt.Printf("Error parsing integer: %v", err)
+		fmt.Printf("Error getting path %v in config: %v\n", path, err)
-		os.Exit(1)
+		return 0
+	}
+	i, err = key.Int()
+	if err != nil {
+		fmt.Printf("Error parsing integer: %v\n", err)
+		return 0
 	}
 	return i
 }
 
+func (config *Configuration) GetAsIntErr(path string) (int, error) {
+	var i int
+	key, err := config.GetKey(path)
+	if err != nil {
+		fmt.Printf("Error getting path %v in config: %v\n", path, err)
+		return 0, err
+	}
+	i, err = key.Int()
+	if err != nil {
+		fmt.Printf("Error parsing integer: %v\n", err)
+		return 0, err
+	}
+	return i, nil
+}
+
 func (config *Configuration) GetAsInts(path string) []int {
-	return config.GetKey(path).Ints(",")
+	key, err := config.GetKey(path)
+	if err != nil {
+		fmt.Printf("Error getting path %v in config: %v\n", path, err)
+		return nil
+	}
+	return key.Ints(",")
+}
+
+func (config *Configuration) GetAsIntsErr(path string) ([]int, error) {
+	key, err := config.GetKey(path)
+	if err != nil {
+		fmt.Printf("Error getting path %v in config: %v\n", path, err)
+		return nil, err
+	}
+	return key.Ints(","), nil
 }
 
 func (config *Configuration) GetAsUInt(path string) uint {
 	var i uint
-	var err error
+	key, err := config.GetKey(path)
-	i, err = config.GetKey(path).Uint()
 	if err != nil {
-		fmt.Printf("Error parsing integer: %v", err)
+		fmt.Printf("Error getting path %v in config: %v\n", path, err)
-		os.Exit(1)
+		return 0
+	}
+	i, err = key.Uint()
+	if err != nil {
+		fmt.Printf("Error parsing integer: %v\n", err)
+		return 0
 	}
 	return i
 }
 
+func (config *Configuration) GetAsUIntErr(path string) (uint, error) {
+	var i uint
+	key, err := config.GetKey(path)
+	if err != nil {
+		fmt.Printf("Error getting path %v in config: %v\n", path, err)
+		return 0, err
+	}
+	i, err = key.Uint()
+	if err != nil {
+		fmt.Printf("Error parsing integer: %v\n", err)
+		return 0, err
+	}
+	return i, nil
+}
+
 func (config *Configuration) GetAsUInts(path string) []uint {
-	return config.GetKey(path).Uints(",")
+	key, err := config.GetKey(path)
+	if err != nil {
+		fmt.Printf("Error getting path %v in config: %v\n", path, err)
+		return nil
+	}
+	return key.Uints(",")
+}
+
+func (config *Configuration) GetAsUIntsErr(path string) ([]uint, error) {
+	key, err := config.GetKey(path)
+	if err != nil {
+		fmt.Printf("Error getting path %v in config: %v\n", path, err)
+		return nil, err
+	}
+	return key.Uints(","), nil
 }
 
 func (config *Configuration) GetAsFloat(path string) float64 {
 	var f float64
-	var err error
+	key, err := config.GetKey(path)
-	f, err = config.GetKey(path).Float64()
 	if err != nil {
-		fmt.Printf("Error parsing float: %v", err)
+		fmt.Printf("Error getting path %v in config: %v\n", path, err)
-		os.Exit(1)
+		return 0
+	}
+	f, err = key.Float64()
+	if err != nil {
+		fmt.Printf("Error parsing float: %v\n", err)
+		return 0
 	}
 	return f
 }
 
+func (config *Configuration) GetAsFloatErr(path string) (float64, error) {
+	var f float64
+	key, err := config.GetKey(path)
+	if err != nil {
+		fmt.Printf("Error getting path %v in config: %v\n", path, err)
+		return 0, err
+	}
+	f, err = key.Float64()
+	if err != nil {
+		fmt.Printf("Error parsing float: %v\n", err)
+		return 0, err
+	}
+	return f, nil
+}
+
 func (config *Configuration) GetAsFloats(path string) []float64 {
-	return config.GetKey(path).Float64s(",")
+	key, err := config.GetKey(path)
+	if err != nil {
+		fmt.Printf("Error getting path %v in config: %v\n", path, err)
+		return nil
+	}
+	return key.Float64s(",")
+}
+
+func (config *Configuration) GetAsFloatsErr(path string) ([]float64, error) {
+	key, err := config.GetKey(path)
+	if err != nil {
+		fmt.Printf("Error getting path %v in config: %v\n", path, err)
+		return nil, err
+	}
+	return key.Float64s(","), nil
 }
 
 func (config *Configuration) GetAsBoolean(path string) bool {
-	var b bool
+	key, err := config.GetKey(path)
-	var err error
-	b, err = config.GetKey(path).Bool()
 	if err != nil {
-		fmt.Printf("Error parsingn bool: %v", err)
+		fmt.Printf("Error getting path %v in config: %v\n", path, err)
-		os.Exit(1)
+		return false
+	}
+	b, err := key.Bool()
+	if err != nil {
+		fmt.Printf("Error parsing bool: %v\n", err)
+		return false
 	}
 	return b
 }
 
-func (config *Configuration) GetAsBooleans(path string) []bool {
+func (config *Configuration) GetAsBooleanErr(path string) (bool, error) {
-	return config.GetKey(path).Bools(",")
+	key, err := config.GetKey(path)
+	if err != nil {
+		fmt.Printf("Error getting path %v in config: %v\n", path, err)
+		return false, err
+	}
+	b, err := key.Bool()
+	if err != nil {
+		fmt.Printf("Error parsing bool: %v\n", err)
+		return false, err
+	}
+	return b, nil
 }
 
-func (config *Configuration) load() {
+func (config *Configuration) GetAsBooleans(path string) []bool {
-	var err error = nil
+	key, err := config.GetKey(path)
+	if err != nil {
+		fmt.Printf("Error getting path %v in config: %v\n", path, err)
+		return nil
+	}
+	return key.Bools(",")
+}
+
+func (config *Configuration) GetAsBooleansErr(path string) ([]bool, error) {
+	key, err := config.GetKey(path)
+	if err != nil {
+		fmt.Printf("Error getting path %v in config: %v\n", path, err)
+		return nil, err
+	}
+	return key.Bools(","), nil
+}
+
+func (config *Configuration) IsSet(path string) bool {
+	key, err := config.GetKey(path)
+	if err != nil {
+		return false
+	}
+
+	return key.Value() != ""
+}
+
+func (config *Configuration) createAndLoad(defaultConfig string) error {
+	err := createFile(config.fileLocation, []byte(defaultConfig))
+	if err != nil {
+		return err
+	}
+	err = config.load()
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (config *Configuration) load() error {
+	var err error
 	config.file, err = ini.Load(config.fileLocation)
 	if err != nil {
-		fmt.Printf("Failed to open configuration file: %v", err)
+		fmt.Printf("Failed to open configuration file: %v\n", err)
-		os.Exit(1)
+		return err
 	}
+	return nil
 }
 
-func (config *Configuration) Reload() {
+func (config *Configuration) Save() error {
-	config.load()
-}
-
-func (config *Configuration) Save() {
 	err := config.file.SaveTo(config.fileLocation)
 	if err != nil {
-		fmt.Printf("Failed to save configuration file: %v", err)
+		fmt.Printf("Failed to save configuration file: %v\n", err)
-		os.Exit(1)
+		return err
 	}
+	return nil
+}
+
+func createFile(fileLocation string, data []byte) error {
+	_, err := os.Stat(fileLocation)
+	if errors.Is(err, os.ErrNotExist) {
+		file, err := os.Create(fileLocation)
+		if err != nil {
+			fmt.Printf("Failed to create file: %v", err)
+			return err
+		}
+		defer file.Close()
+		_, err = file.Write(data)
+		if err != nil {
+			fmt.Printf("Error writing to file: %v", err)
+			return err
+		}
+		return nil
+	} else if err != nil {
+		fmt.Printf("Error creating file: %v", err)
+		return err
+	}
+
+	fmt.Printf("File already exists...")
+	return nil
 }