redo magefile

magefile.go

@@ -4,125 +4,123 @@
 package main
 
 import (
-	"bytes"
 	"fmt"
 	"io/ioutil"
 	"os"
 	"path/filepath"
 	"unicode"
+	"unicode/utf8"
 
 	"github.com/magefile/mage/mg"
 	"github.com/magefile/mage/sh"
+	"github.com/xeipuuv/gojsonschema"
 )
 
 const (
 	zipName    = "DigitalStorageTweaks.zip"
 	contentDir = "./ContentLib"
 	pluginFile = "./DigitalStorageTweaks.uplugin"
-	targetDirs = "Windows WindowsServer LinuxServer"
 )
 
-var Default = Package
+// Default target
+var Default = Build
 
-// Package creates the distribution zip file
+// Build runs the full pipeline
+func Build() {
+	mg.SerialDeps(Validate, Package)
+}
+
+// Package creates the distribution zip
 func Package() error {
-	mg.Deps(SanitizeContent)
-	defer Clean(false) // Clean temp dirs but keep zip
+	fmt.Println("Packaging files...")
 
-	fmt.Println("Creating target directories...")
+	// Create target directories
 	for _, dir := range []string{"Windows", "WindowsServer", "LinuxServer"} {
 		if err := os.MkdirAll(dir, 0755); err != nil {
-			return fmt.Errorf("failed to create directory %s: %v", dir, err)
+			return fmt.Errorf("creating %s: %w", dir, err)
 		}
-
-		fmt.Printf("Copying files to %s...\n", dir)
 		if err := sh.Run("cp", "-r", contentDir, pluginFile, dir+"/"); err != nil {
-			return fmt.Errorf("failed to copy files to %s: %v", dir, err)
+			return fmt.Errorf("copying to %s: %w", dir, err)
 		}
 	}
 
-	fmt.Println("Creating zip archive...")
-	return sh.Run("7z", "a", "-r", zipName, "Windows/", "LinuxServer/", "WindowsServer/")
+	// Create zip
+	if err := sh.Run("7z", "a", "-r", zipName, "Windows/", "LinuxServer/", "WindowsServer/"); err != nil {
+		return fmt.Errorf("creating zip: %w", err)
+	}
+
+	// Clean temp dirs
+	return Clean("Windows", "WindowsServer", "LinuxServer")
 }
 
-// Clean removes generated artifacts
-func Clean(includeZip bool) error {
-	fmt.Println("Cleaning artifacts...")
-	paths := []string{"Windows", "WindowsServer", "LinuxServer"}
-	if includeZip {
-		paths = append(paths, zipName)
-	}
-	for _, path := range paths {
-		if err := sh.Rm(path); err != nil {
-			return err
-		}
-	}
-	return nil
-}
+// Validate checks all content files
+func Validate() error {
+	fmt.Println("Validating files...")
 
-// SanitizeContent cleans all text files of non-ASCII and ensures CRLF line endings
-func SanitizeContent() error {
-	fmt.Println("Sanitizing content files...")
-
-	// Process plugin file
-	if err := sanitizeFile(pluginFile); err != nil {
-		return fmt.Errorf("plugin file sanitization failed: %v", err)
+	// Check plugin file
+	if err := checkFile(pluginFile); err != nil {
+		return fmt.Errorf("plugin file: %w", err)
 	}
 
-	// Process content directory
+	// Check content directory
 	return filepath.Walk(contentDir, func(path string, info os.FileInfo, err error) error {
 		if err != nil || info.IsDir() {
 			return err
 		}
-
-		// Skip binary files
-		switch filepath.Ext(path) {
-		case ".png", ".jpg", ".jpeg", ".bmp", ".gif", ".dds", ".tga", ".psd", ".fbx", ".uasset", ".umap":
-			return nil
-		default:
-			return sanitizeFile(path)
-		}
+		return checkFile(path)
 	})
 }
 
-func sanitizeFile(path string) error {
-	content, err := ioutil.ReadFile(path)
+func checkFile(path string) error {
+	// Skip binary files
+	switch filepath.Ext(path) {
+	case ".png", ".jpg", ".jpeg", ".bmp", ".gif", ".dds", ".tga", ".psd", ".fbx", ".uasset", ".umap":
+		return nil
+	case ".json":
+		return validateJSON(path)
+	default:
+		return validateEncoding(path)
+	}
+}
+
+func validateJSON(path string) error {
+	schemaLoader := gojsonschema.NewReferenceLoader("https://raw.githubusercontent.com/budak7273/ContentLib_Documentation/main/JsonSchemas/CL_Recipe.json")
+	documentLoader := gojsonschema.NewReferenceLoader("file:///" + filepath.ToSlash(path))
+
+	result, err := gojsonschema.Validate(schemaLoader, documentLoader)
 	if err != nil {
-		return fmt.Errorf("failed to read %s: %v", path, err)
+		return fmt.Errorf("schema validation failed: %w", err)
 	}
 
-	// First fix any encoding issues by converting to valid UTF-8
-	content = bytes.ToValidUTF8(content, []byte{})
-
-	// Remove non-ASCII characters but preserve standard whitespace
-	cleanContent := bytes.Map(func(r rune) rune {
-		switch {
-		case r > unicode.MaxASCII:
-			return -1 // Remove non-ASCII
-		case r == '\t', r == '\n', r == '\r':
-			return r // Keep standard whitespace
-		case r < 32 || r == 127:
-			return -1 // Remove control characters
-		default:
-			return r // Keep regular ASCII
-		}
-	}, content)
-
-	// Normalize line endings to CRLF
-	cleanContent = bytes.ReplaceAll(cleanContent, []byte("\r\n"), []byte("\n"))
-	cleanContent = bytes.ReplaceAll(cleanContent, []byte("\n"), []byte("\r\n"))
-
-	// Only write back if changes were made
-	if !bytes.Equal(content, cleanContent) {
-		fmt.Printf("Sanitizing %s\n", path)
-		fileInfo, err := os.Stat(path)
-		if err != nil {
-			return fmt.Errorf("failed to get file info for %s: %v", path, err)
-		}
-		if err := ioutil.WriteFile(path, cleanContent, fileInfo.Mode()); err != nil {
-			return fmt.Errorf("failed to write %s: %v", path, err)
-		}
+	if !result.Valid() {
+		return fmt.Errorf("invalid JSON schema: %v", result.Errors())
+	}
+	return nil
+}
+
+func validateEncoding(path string) error {
+	content, err := ioutil.ReadFile(path)
+	if err != nil {
+		return err
+	}
+
+	// Check for non-ASCII
+	for i := 0; i < len(content); i++ {
+		if content[i] > unicode.MaxASCII {
+			r, _ := utf8.DecodeRune(content[i:])
+			return fmt.Errorf("non-ASCII character %U at position %d", r, i)
+		}
+	}
+	return nil
+}
+
+// Clean removes all build artifacts
+func Clean(list ...string) error {
+	fmt.Println("Cleaning up...")
+	for _, f := range list {
+		if err := os.RemoveAll(f); err != nil {
+			return fmt.Errorf("failed to remove %s: %w", f, err)
+		}
 	}
-
 	return nil
 }