envy/cmd/utils/other.go

package utils

import (
	"errors"
	"fmt"
	"os"
	"path"
	"regexp"
	"strings"

	"github.com/pelletier/go-toml"
	"gorm.io/gorm"
)

func StopIfErr(err error) {
	if err != nil {
		ErrPrint(err.Error())
		os.Exit(1)
	}
}

func GetEnvy() (*toml.Tree, error) {
	cwd, err := os.Getwd()
	if err != nil {
		return nil, errors.New("Not able to fetch working directory: " + err.Error())
	}

	_, err = os.Stat(path.Join(cwd, "envy.toml"))

	// file exists
	if err == nil {
		envyFile, err := toml.LoadFile(path.Join(cwd, "envy.toml"))
		if err != nil {
			return nil, errors.New("Error occured while reading envy.toml file:" + err.Error())
		}
		return envyFile, nil
	}

	// file does not exist
	if os.IsNotExist(err) {
		return nil, errors.New("envy.toml file doesn't exist in the current directory")
	} else {
		return nil, errors.New("Some error occured:" + err.Error())
	}
}

func GetKey(t *toml.Tree, key string) (string, error) {
	v := t.Get(key)
	if v == nil {
		return "", fmt.Errorf("key %v not found", v)
	}
	s, ok := v.(string)
	if !ok {
		return "", fmt.Errorf("key %q is %T, expected string", key, v)
	}
	return s, nil
}

func WriteEnvy(tree *toml.Tree) error {
	data, err := tree.Marshal()
	if err != nil {
		return err
	}

	cwd, err := os.Getwd()
	if err != nil {
		return err
	}
	os.WriteFile(path.Join(cwd, "envy.toml"), data, 0744)

	return nil
}

func GetProject(name string) (Project, error) {
	InitDb()

	var dbProject Project
	result := DB.Where("name = ?", name).First(&dbProject)

	if result.Error != nil {
		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
			return Project{}, errors.New("Project with the name " + name + " not found in the database")
		} else {
			return Project{}, errors.New("Some error occured: " + result.Error.Error())
		}
	}
	return dbProject, nil
}

func GetEnvironments(project uint) ([]Environment, error) {
	InitDb()

	var dbEnvs []Environment
	result := DB.Where("project_id = ?", project).Find(&dbEnvs)

	if result.Error != nil {
		return nil, errors.New("Some error occured: " + result.Error.Error())
	}
	return dbEnvs, nil
}

func GetEnvironment(project uint, environment string) (Environment, error) {
	InitDb()

	var dbEnv Environment
	result := DB.Where("project_id = ? AND name = ?", project, environment).First(&dbEnv)

	if result.Error != nil {
		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
			return Environment{}, errors.New("Environment with the name " + environment + " not found in the database")
		} else {
			return Environment{}, errors.New("Some error occured: " + result.Error.Error())
		}
	}
	return dbEnv, nil
}

func ParseEnv(env string) string {
	re := regexp.MustCompile(`^\s*(#?)\s*([A-Z0-9_]+)\s*=\s*(?:"([^"\n]+)"|([^"\n]+))$`)

	var envs string

	for _, line := range strings.Split(string(env), "\n") {
		matches := re.FindStringSubmatch(line)
		var key, value string
		var enabled bool
		if matches != nil {
			enabled = matches[1] == ""
			key = matches[2]   // the key
			value = matches[3] // quoted value
			if value == "" {
				value = matches[4] // unquoted value
			}
			var comment = ""
			if !enabled {
				comment = "#"
			}
			envs += fmt.Sprintf("%v%v=%v\n", comment, key, value)
		}
	}

	return envs
}


type Env struct {
	Enabled bool
	Key string
	Value string
}

func ParseEnvToStruct(env string) []Env {
	re := regexp.MustCompile(`^\s*(#?)\s*([A-Z0-9_]+)\s*=\s*(?:"([^"\n]+)"|([^"\n]+))$`)

	var envs []Env

	for _, line := range strings.Split(string(env), "\n") {
		matches := re.FindStringSubmatch(line)
		var env Env
		if matches != nil {
			env.Enabled = matches[1] == ""
			env.Key = matches[2]   // the key
			env.Value = matches[3] // quoted value
			if env.Value == "" {
				env.Value = matches[4] // unquoted value
			}
			envs = append(envs, env)
		}
	}

	return envs
}


func ParseEnvStruct(envs []Env) string {
	var env string

	for _, en := range envs {
		comment := ""
		if !en.Enabled {
			comment = "#"
		}
		env += fmt.Sprintf("%v%v=%v\n", comment, en.Key, en.Value)
	}

	return env
}