ezconf/ini.go

package ezconf

import (
	"errors"
	"fmt"
	"os"
	"strings"

	"gopkg.in/ini.v1"
)

type Configuration struct {
	fileLocation string
	file         *ini.File
}

func CreateConfigurationFile(fileLocation string, defaultConfig string) error {
	err := createFile(fileLocation, []byte(defaultConfig))
	if err != nil {
		return err
	}
	return nil
}

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 {
		return nil, err
	}
	return section, nil
}

func GetChildSection(section *ini.Section, childSectionName string) (childSection *ini.Section, err error) {
	childSections := section.ChildSections()
	for _, childSection = range childSections {
		if childSection.Name() == childSectionName {
			return
		}
	}
	return nil, errors.New("subsection " + childSectionName + " not found")
}

func GetChildSections(section *ini.Section) (childSections []*ini.Section) {
	return section.ChildSections()
}

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, err := config.GetSection(sectionMask)
	if err != nil {
		return nil, err
	}
	keyName := splitPaths[len(splitPaths)-1]
	key, err := section.GetKey(keyName)
	if err != nil {
		return nil, err
	}
	return key, nil
}

func (config *Configuration) SetValue(path string, value string) {
	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 {
	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
	key, err := config.GetKey(path)
	if err != nil {
		fmt.Printf("Error getting path %v in config: %v\n", path, err)
		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) GetAsInt64(path string) int64 {
	var i int64
	key, err := config.GetKey(path)
	if err != nil {
		fmt.Printf("Error getting path %v in config: %v\n", path, err)
		return 0
	}
	i, err = key.Int64()
	if err != nil {
		fmt.Printf("Error parsing integer: %v\n", err)
		return 0
	}
	return i
}

func (config *Configuration) GetAsInt64Err(path string) (int64, error) {
	var i int64
	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.Int64()
	if err != nil {
		fmt.Printf("Error parsing integer: %v\n", err)
		return 0, err
	}
	return i, nil
}

func (config *Configuration) GetAsInts(path string) []int {
	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
	key, err := config.GetKey(path)
	if err != nil {
		fmt.Printf("Error getting path %v in config: %v\n", path, err)
		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 {
	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
	key, err := config.GetKey(path)
	if err != nil {
		fmt.Printf("Error getting path %v in config: %v\n", path, err)
		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 {
	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 {
	key, err := config.GetKey(path)
	if err != nil {
		fmt.Printf("Error getting path %v in config: %v\n", path, err)
		return false
	}
	b, err := key.Bool()
	if err != nil {
		fmt.Printf("Error parsing bool: %v\n", err)
		return false
	}
	return b
}

func (config *Configuration) GetAsBooleanErr(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 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) GetAsBooleans(path string) []bool {
	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\n", err)
		return err
	}
	return nil
}

func (config *Configuration) Save() error {
	err := config.file.SaveTo(config.fileLocation)
	if err != nil {
		fmt.Printf("Failed to save configuration file: %v\n", err)
		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
}