dave/BigChef
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 50 Wiki Activity

Rework variables to not be commands...

Browse Source
This commit is contained in:
PhatPhuckDave
2025-12-19 11:30:28 +01:00
parent a18573c9f8
commit 09cdc91761
4 changed files with 83 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
utils/modifycommand.go
View File

@@ -263,24 +263,29 @@ func ExpandGlobs(patterns map[string]struct{}) ([]string, error) {
return files, nil
}
func LoadCommands(args []string) ([]ModifyCommand, error) {
func LoadCommands(args []string) ([]ModifyCommand, map[string]interface{}, error) {
loadCommandsLogger := modifyCommandLogger.WithPrefix("LoadCommands")
loadCommandsLogger.Debug("Loading commands from arguments (cook files or direct patterns)")
loadCommandsLogger.Trace("Input arguments: %v", args)
commands := []ModifyCommand{}
modifiers := make(map[string]interface{})
for _, arg := range args {
loadCommandsLogger.Debug("Processing argument for commands: %q", arg)
var newCommands []ModifyCommand
var newModifiers map[string]interface{}
var err error
// Check file extension to determine format
if strings.HasSuffix(arg, ".toml") {
loadCommandsLogger.Debug("Loading TOML commands from %q", arg)
newCommands, err = LoadCommandsFromTomlFiles(arg)
newCommands, newModifiers, err = LoadCommandsFromTomlFiles(arg)
if err != nil {
loadCommandsLogger.Error("Failed to load TOML commands from argument %q: %v", arg, err)
return nil, fmt.Errorf("failed to load commands from TOML files: %w", err)
return nil, nil, fmt.Errorf("failed to load commands from TOML files: %w", err)
}
for k, v := range newModifiers {
modifiers[k] = v
}
} else {
// Default to YAML for .yml, .yaml, or any other extension
@@ -288,7 +293,7 @@ func LoadCommands(args []string) ([]ModifyCommand, error) {
newCommands, err = LoadCommandsFromCookFiles(arg)
if err != nil {
loadCommandsLogger.Error("Failed to load YAML commands from argument %q: %v", arg, err)
return nil, fmt.Errorf("failed to load commands from cook files: %w", err)
return nil, nil, fmt.Errorf("failed to load commands from cook files: %w", err)
}
}
@@ -303,8 +308,8 @@ func LoadCommands(args []string) ([]ModifyCommand, error) {
}
}
loadCommandsLogger.Info("Finished loading commands. Total %d commands loaded", len(commands))
return commands, nil
loadCommandsLogger.Info("Finished loading commands. Total %d commands and %d modifiers loaded", len(commands), len(modifiers))
return commands, modifiers, nil
}
func LoadCommandsFromCookFiles(pattern string) ([]ModifyCommand, error) {
@@ -395,16 +400,17 @@ func FilterCommands(commands []ModifyCommand, filter string) []ModifyCommand {
return filteredCommands
}
func LoadCommandsFromTomlFiles(pattern string) ([]ModifyCommand, error) {
func LoadCommandsFromTomlFiles(pattern string) ([]ModifyCommand, map[string]interface{}, error) {
loadTomlFilesLogger := modifyCommandLogger.WithPrefix("LoadCommandsFromTomlFiles").WithField("pattern", pattern)
loadTomlFilesLogger.Debug("Loading commands from TOML files based on pattern")
loadTomlFilesLogger.Trace("Input pattern: %q", pattern)
static, pattern := SplitPattern(pattern)
commands := []ModifyCommand{}
modifiers := make(map[string]interface{})
tomlFiles, err := doublestar.Glob(os.DirFS(static), pattern)
if err != nil {
loadTomlFilesLogger.Error("Failed to glob TOML files for pattern %q: %v", pattern, err)
return nil, fmt.Errorf("failed to glob TOML files: %w", err)
return nil, nil, fmt.Errorf("failed to glob TOML files: %w", err)
}
loadTomlFilesLogger.Debug("Found %d TOML files for pattern %q", len(tomlFiles), pattern)
loadTomlFilesLogger.Trace("TOML files found: %v", tomlFiles)
@@ -417,30 +423,34 @@ func LoadCommandsFromTomlFiles(pattern string) ([]ModifyCommand, error) {
tomlFileData, err := os.ReadFile(tomlFile)
if err != nil {
loadTomlFilesLogger.Error("Failed to read TOML file %q: %v", tomlFile, err)
return nil, fmt.Errorf("failed to read TOML file: %w", err)
return nil, nil, fmt.Errorf("failed to read TOML file: %w", err)
}
loadTomlFilesLogger.Trace("Read %d bytes from TOML file %q", len(tomlFileData), tomlFile)
newCommands, err := LoadCommandsFromTomlFile(tomlFileData)
newCommands, newModifiers, err := LoadCommandsFromTomlFile(tomlFileData)
if err != nil {
loadTomlFilesLogger.Error("Failed to load commands from TOML file data for %q: %v", tomlFile, err)
return nil, fmt.Errorf("failed to load commands from TOML file: %w", err)
return nil, nil, fmt.Errorf("failed to load commands from TOML file: %w", err)
}
commands = append(commands, newCommands...)
loadTomlFilesLogger.Debug("Added %d commands from TOML file %q. Total commands now: %d", len(newCommands), tomlFile, len(commands))
for k, v := range newModifiers {
modifiers[k] = v
}
loadTomlFilesLogger.Debug("Added %d commands and %d modifiers from TOML file %q. Total commands now: %d", len(newCommands), len(newModifiers), tomlFile, len(commands))
}
loadTomlFilesLogger.Debug("Finished loading commands from TOML files. Total %d commands", len(commands))
return commands, nil
loadTomlFilesLogger.Debug("Finished loading commands from TOML files. Total %d commands and %d modifiers", len(commands), len(modifiers))
return commands, modifiers, nil
}
func LoadCommandsFromTomlFile(tomlFileData []byte) ([]ModifyCommand, error) {
func LoadCommandsFromTomlFile(tomlFileData []byte) ([]ModifyCommand, map[string]interface{}, error) {
loadTomlCommandLogger := modifyCommandLogger.WithPrefix("LoadCommandsFromTomlFile")
loadTomlCommandLogger.Debug("Unmarshaling commands from TOML file data")
loadTomlCommandLogger.Trace("TOML file data length: %d", len(tomlFileData))
// TOML structure for commands array
// TOML structure for commands array and top-level modifiers
var tomlData struct {
Commands []ModifyCommand `toml:"commands"`
Modifiers map[string]interface{} `toml:"modifiers,omitempty"`
Commands []ModifyCommand `toml:"commands"`
// Also support direct array without wrapper
DirectCommands []ModifyCommand `toml:"-"`
}
@@ -449,10 +459,19 @@ func LoadCommandsFromTomlFile(tomlFileData []byte) ([]ModifyCommand, error) {
err := toml.Unmarshal(tomlFileData, &tomlData)
if err != nil {
loadTomlCommandLogger.Error("Failed to unmarshal TOML file data: %v", err)
return nil, fmt.Errorf("failed to unmarshal TOML file: %w", err)
return nil, nil, fmt.Errorf("failed to unmarshal TOML file: %w", err)
}
var commands []ModifyCommand
modifiers := make(map[string]interface{})
// Extract top-level modifiers
if len(tomlData.Modifiers) > 0 {
loadTomlCommandLogger.Debug("Found %d top-level modifiers", len(tomlData.Modifiers))
for k, v := range tomlData.Modifiers {
modifiers[k] = v
}
}
// If we found commands in the wrapped structure, use those
if len(tomlData.Commands) > 0 {
@@ -460,18 +479,22 @@ func LoadCommandsFromTomlFile(tomlFileData []byte) ([]ModifyCommand, error) {
loadTomlCommandLogger.Debug("Found %d commands in wrapped TOML structure", len(commands))
} else {
// Try to parse as direct array (similar to YAML format)
commands = []ModifyCommand{}
err = toml.Unmarshal(tomlFileData, &commands)
directCommands := []ModifyCommand{}
err = toml.Unmarshal(tomlFileData, &directCommands)
if err != nil {
loadTomlCommandLogger.Error("Failed to unmarshal TOML file data as direct array: %v", err)
return nil, fmt.Errorf("failed to unmarshal TOML file as direct array: %w", err)
return nil, nil, fmt.Errorf("failed to unmarshal TOML file as direct array: %w", err)
}
if len(directCommands) > 0 {
commands = directCommands
loadTomlCommandLogger.Debug("Found %d commands in direct TOML array", len(directCommands))
}
loadTomlCommandLogger.Debug("Found %d commands in direct TOML array", len(commands))
}
loadTomlCommandLogger.Debug("Successfully unmarshaled %d commands", len(commands))
loadTomlCommandLogger.Debug("Successfully unmarshaled %d commands and %d modifiers", len(commands), len(modifiers))
loadTomlCommandLogger.Trace("Unmarshaled commands: %v", commands)
return commands, nil
loadTomlCommandLogger.Trace("Unmarshaled modifiers: %v", modifiers)
return commands, modifiers, nil
}
// ConvertYAMLToTOML converts YAML files to TOML format