ezconf/ini.go

package ezconf

import (
	"errors"
	"fmt"
	"gopkg.in/ini.v1"
	"os"
	"strings"
)

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

func CreateConfigurationFile(fileLocation string, defaultConfig string) {
	createFile(fileLocation, []byte(defaultConfig))
}

func NewConfiguration(fileLocation string, defaultConfig string) *Configuration {
	conf := new(Configuration)
	conf.fileLocation = fileLocation
	conf.createAndLoad(defaultConfig)
	return conf
}

func LoadConfiguration(fileLocation string) *Configuration {
	conf := new(Configuration)
	conf.fileLocation = fileLocation
	conf.load()
	return conf
}

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++ {
		file.NewSections()
	}

	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", path, err)
			os.Exit(1)
		}
		fmt.Printf("New Val: Split Path: %v", splitPath)
	}
	key, err = config.GetKey(path)
	if err != nil {
		fmt.Printf("Error getting path %v in config: %v", path, err)
		os.Exit(1)
	}
	key.SetValue(value)
}

func (config *Configuration) GetAsString(path string) string {
	key, err := config.GetKey(path)
	if err != nil {
		fmt.Printf("Error getting path %v in config: %v", path, err)
	}
	return key.String()
}

func (config *Configuration) GetAsStrings(path string) []string {
	key, err := config.GetKey(path)
	if err != nil {
		fmt.Printf("Error getting path %v in config: %v", path, err)
	}
	return key.Strings(",")
}

func (config *Configuration) GetAsInt(path string) int {
	var i int
	var err error
	key, err := config.GetKey(path)
	if err != nil {
		fmt.Printf("Error getting path %v in config: %v", path, err)
	}
	i, err = key.Int()
	if err != nil {
		fmt.Printf("Error parsing integer: %v", err)
		os.Exit(1)
	}
	return i
}

func (config *Configuration) GetAsInts(path string) []int {
	key, err := config.GetKey(path)
	if err != nil {
		fmt.Printf("Error getting path %v in config: %v", path, err)
	}
	return key.Ints(",")
}

func (config *Configuration) GetAsUInt(path string) uint {
	var i uint
	var err error
	key, err := config.GetKey(path)
	if err != nil {
		fmt.Printf("Error getting path %v in config: %v", path, err)
	}
	i, err = key.Uint()
	if err != nil {
		fmt.Printf("Error parsing integer: %v", err)
		os.Exit(1)
	}
	return i
}

func (config *Configuration) GetAsUInts(path string) []uint {
	key, err := config.GetKey(path)
	if err != nil {
		fmt.Printf("Error getting path %v in config: %v", path, err)
	}
	return key.Uints(",")
}

func (config *Configuration) GetAsFloat(path string) float64 {
	var f float64
	var err error
	key, err := config.GetKey(path)
	if err != nil {
		fmt.Printf("Error getting path %v in config: %v", path, err)
	}
	f, err = key.Float64()
	if err != nil {
		fmt.Printf("Error parsing float: %v", err)
		os.Exit(1)
	}
	return f
}

func (config *Configuration) GetAsFloats(path string) []float64 {
	key, err := config.GetKey(path)
	if err != nil {
		fmt.Printf("Error getting path %v in config: %v", path, err)
	}
	return key.Float64s(",")
}

func (config *Configuration) GetAsBoolean(path string) bool {
	var b bool
	var err error
	key, err := config.GetKey(path)
	if err != nil {
		fmt.Printf("Error getting path %v in config: %v", path, err)
	}
	b, err = key.Bool()
	if err != nil {
		fmt.Printf("Error parsingn bool: %v", err)
		os.Exit(1)
	}
	return b
}

func (config *Configuration) GetAsBooleans(path string) []bool {
	key, err := config.GetKey(path)
	if err != nil {
		fmt.Printf("Error getting path %v in config: %v", path, err)
	}
	return key.Bools(",")
}

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) {
	createFile(config.fileLocation, []byte(defaultConfig))
	config.load()
}

func (config *Configuration) load() {
	var err error
	config.file, err = ini.Load(config.fileLocation)
	if err != nil {
		fmt.Printf("Failed to open configuration file: %v", err)
		os.Exit(1)
	}
}

func (config *Configuration) Save() {
	err := config.file.SaveTo(config.fileLocation)
	if err != nil {
		fmt.Printf("Failed to save configuration file: %v", err)
		os.Exit(1)
	}
}

func createFile(fileLocation string, data []byte) {
	_, 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)
			os.Exit(1)
		}
		_, err = file.Write(data)
		if err != nil {
			fmt.Printf("Error writing to file: %v", err)
			os.Exit(1)
		}
	} else if err != nil {
		fmt.Printf("Error creating file: %v", err)
		os.Exit(1)
	} else {
		fmt.Printf("File already exists...")
	}
}