v2.0.0-alpha.30

v2/cmd/wails/internal/commands/dev/dev.go

@@ -53,6 +53,13 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 	extensions := "go"
 	command.StringFlag("e", "Extensions to trigger rebuilds (comma separated) eg go,js,css,html", &extensions)
 
+	// extensions to trigger rebuilds
+	showWarnings := false
+	command.BoolFlag("w", "Show warnings", &showWarnings)
+
+	loglevel := ""
+	command.StringFlag("loglevel", "Loglevel to use - Trace, Debug, Info, Warning, Error", &loglevel)
+
 	command.Action(func() error {
 
 		// Create logger
@@ -78,7 +85,7 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 
 		// Do initial build
 		logger.Println("Building application for development...")
-		newProcess, err := restartApp(logger, "dev", ldflags, compilerCommand, debugBinaryProcess)
+		newProcess, err := restartApp(logger, "dev", ldflags, compilerCommand, debugBinaryProcess, loglevel)
 		if newProcess != nil {
 			debugBinaryProcess = newProcess
 		}
@@ -117,7 +124,9 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 				}
 
 				if !rebuild {
-					LogDarkYellow("[File change] %s did not match extension list (%s)", event.Name, extensions)
+					if showWarnings {
+						LogDarkYellow("[File change] %s did not match extension list (%s)", event.Name, extensions)
+					}
 					return
 				}
 
@@ -126,7 +135,7 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 				// Do a rebuild
 
 				// Try and build the app
-				newBinaryProcess, err := restartApp(logger, "dev", ldflags, compilerCommand, debugBinaryProcess)
+				newBinaryProcess, err := restartApp(logger, "dev", ldflags, compilerCommand, debugBinaryProcess, loglevel)
 				if err != nil {
 					fmt.Printf("Error during build: %s", err.Error())
 					return
@@ -215,7 +224,7 @@ exit:
 	}
 }
 
-func restartApp(logger *clilogger.CLILogger, outputType string, ldflags string, compilerCommand string, debugBinaryProcess *process.Process) (*process.Process, error) {
+func restartApp(logger *clilogger.CLILogger, outputType string, ldflags string, compilerCommand string, debugBinaryProcess *process.Process, loglevel string) (*process.Process, error) {
 
 	appBinary, err := buildApp(logger, outputType, ldflags, compilerCommand)
 	println()
@@ -239,7 +248,7 @@ func restartApp(logger *clilogger.CLILogger, outputType string, ldflags string,
 	// TODO: Generate `backend.js`
 
 	// Start up new binary
-	newProcess := process.NewProcess(logger, appBinary)
+	newProcess := process.NewProcess(logger, appBinary, "-loglevel", loglevel)
 	err = newProcess.Start()
 	if err != nil {
 		// Remove binary

v2/cmd/wails/internal/commands/update/update.go

@@ -18,14 +18,14 @@ import (
 func AddSubcommand(app *clir.Cli, w io.Writer, currentVersion string) error {
 
 	command := app.NewSubCommand("update", "Update the Wails CLI")
-	command.LongDescription(`This command allows you to update your version of Wails.`)
+	command.LongDescription(`This command allows you to update your version of the Wails CLI.`)
 
 	// Setup flags
 	var prereleaseRequired bool
-	command.BoolFlag("pre", "Update to latest Prerelease", &prereleaseRequired)
+	command.BoolFlag("pre", "Update CLI to latest Prerelease", &prereleaseRequired)
 
 	var specificVersion string
-	command.StringFlag("version", "Install a specific version (Overrides other flags)", &specificVersion)
+	command.StringFlag("version", "Install a specific version (Overrides other flags) of the CLI", &specificVersion)
 
 	command.Action(func() error {
 
@@ -143,7 +143,7 @@ func updateToVersion(logger *clilogger.CLILogger, targetVersion *github.Semantic
 	}
 
 	fmt.Println()
-	logger.Print("Installing Wails " + desiredVersion + "...")
+	logger.Print("Installing Wails CLI " + desiredVersion + "...")
 
 	// Run command in non module directory
 	homeDir, err := os.UserHomeDir()
@@ -158,7 +158,7 @@ func updateToVersion(logger *clilogger.CLILogger, targetVersion *github.Semantic
 		return err
 	}
 	fmt.Println()
-	logger.Println("Wails updated to " + desiredVersion)
+	logger.Println("Wails CLI updated to " + desiredVersion)
 
 	return nil
 }

v2/cmd/wails/version.go

@@ -1,3 +1,3 @@
 package main
 
-var version = "v2.0.0-alpha.28"
+var version = "v2.0.0-alpha.30"

v2/internal/app/debug.go

@@ -4,8 +4,9 @@ package app
 
 import (
 	"flag"
-	"github.com/wailsapp/wails/v2/pkg/logger"
 	"strings"
+
+	"github.com/wailsapp/wails/v2/pkg/logger"
 )
 
 // Init initialises the application for a debug environment
@@ -19,10 +20,10 @@ func (a *App) Init() error {
 	}
 
 	// Set log levels
-	greeting := flag.String("loglevel", "debug", "Loglevel to use - Trace, Debug, Info, Warning, Error")
+	loglevel := flag.String("loglevel", "debug", "Loglevel to use - Trace, Debug, Info, Warning, Error")
 	flag.Parse()
-	if len(*greeting) > 0 {
-		switch strings.ToLower(*greeting) {
+	if len(*loglevel) > 0 {
+		switch strings.ToLower(*loglevel) {
 		case "trace":
 			a.logger.SetLogLevel(logger.TRACE)
 		case "info":

v2/internal/app/dev.go

@@ -4,11 +4,14 @@ package app
 
 import (
 	"context"
+	"flag"
+	"strings"
 	"sync"
 
 	"github.com/wailsapp/wails/v2/internal/bridge"
 	"github.com/wailsapp/wails/v2/internal/menumanager"
 
+	clilogger "github.com/wailsapp/wails/v2/pkg/logger"
 	"github.com/wailsapp/wails/v2/pkg/options"
 
 	"github.com/wailsapp/wails/v2/internal/binding"
@@ -66,7 +69,23 @@ func CreateApp(appoptions *options.App) (*App, error) {
 
 	// Set up logger
 	myLogger := logger.New(appoptions.Logger)
-	myLogger.SetLogLevel(appoptions.LogLevel)
+
+	loglevel := flag.String("loglevel", "debug", "Loglevel to use - Trace, Debug, Info, Warning, Error")
+	flag.Parse()
+	if len(*loglevel) > 0 {
+		switch strings.ToLower(*loglevel) {
+		case "trace":
+			myLogger.SetLogLevel(clilogger.TRACE)
+		case "info":
+			myLogger.SetLogLevel(clilogger.INFO)
+		case "warning":
+			myLogger.SetLogLevel(clilogger.WARNING)
+		case "error":
+			myLogger.SetLogLevel(clilogger.ERROR)
+		default:
+			myLogger.SetLogLevel(appoptions.LogLevel)
+		}
+	}
 
 	// Create the menu manager
 	menuManager := menumanager.NewManager()

v2/internal/binding/generate.go

@@ -58,7 +58,7 @@ const backend = {`)
 		sortedPackageNames.Add(packageName)
 	}
 	sortedPackageNames.Sort()
-	for _, packageName := range sortedPackageNames.AsSlice() {
+	sortedPackageNames.Each(func(packageName string) {
 		packages := store[packageName]
 		output.WriteString(fmt.Sprintf("  \"%s\": {", packageName))
 		output.WriteString("\n")
@@ -67,7 +67,8 @@ const backend = {`)
 			sortedStructNames.Add(structName)
 		}
 		sortedStructNames.Sort()
-		for _, structName := range sortedStructNames.AsSlice() {
+
+		sortedStructNames.Each(func(structName string) {
 			structs := packages[structName]
 			output.WriteString(fmt.Sprintf("    \"%s\": {", structName))
 			output.WriteString("\n")
@@ -78,7 +79,7 @@ const backend = {`)
 			}
 			sortedMethodNames.Sort()
 
-			for _, methodName := range sortedMethodNames.AsSlice() {
+			sortedMethodNames.Each(func(methodName string) {
 				methodDetails := structs[methodName]
 				output.WriteString("      /**\n")
 				output.WriteString("       * " + methodName + "\n")
@@ -109,13 +110,16 @@ const backend = {`)
 				output.WriteString("\n")
 				output.WriteString(fmt.Sprintf("      },"))
 				output.WriteString("\n")
-			}
+
+			})
+
 			output.WriteString(fmt.Sprintf("    }"))
 			output.WriteString("\n")
-		}
+		})
+
 		output.WriteString(fmt.Sprintf("  }\n"))
 		output.WriteString("\n")
-	}
+	})
 
 	output.WriteString(`};
 export default backend;`)

v2/internal/ffenestri/menu_darwin.c

@@ -180,151 +180,151 @@ id processAcceleratorKey(const char *key) {
         return str("");
     }
 
-    if( STREQ(key, "Backspace") ) {
+    if( STREQ(key, "backspace") ) {
         return strunicode(0x0008);
     }
-    if( STREQ(key, "Tab") ) {
+    if( STREQ(key, "tab") ) {
         return strunicode(0x0009);
     }
-    if( STREQ(key, "Return") ) {
+    if( STREQ(key, "return") ) {
         return strunicode(0x000d);
     }
-    if( STREQ(key, "Escape") ) {
+    if( STREQ(key, "escape") ) {
         return strunicode(0x001b);
     }
-    if( STREQ(key, "Left") ) {
+    if( STREQ(key, "left") ) {
         return strunicode(0x001c);
     }
-    if( STREQ(key, "Right") ) {
+    if( STREQ(key, "right") ) {
         return strunicode(0x001d);
     }
-    if( STREQ(key, "Up") ) {
+    if( STREQ(key, "up") ) {
         return strunicode(0x001e);
     }
-    if( STREQ(key, "Down") ) {
+    if( STREQ(key, "down") ) {
         return strunicode(0x001f);
     }
-    if( STREQ(key, "Space") ) {
+    if( STREQ(key, "space") ) {
         return strunicode(0x0020);
     }
-    if( STREQ(key, "Delete") ) {
+    if( STREQ(key, "delete") ) {
         return strunicode(0x007f);
     }
-    if( STREQ(key, "Home") ) {
+    if( STREQ(key, "home") ) {
         return strunicode(0x2196);
     }
-    if( STREQ(key, "End") ) {
+    if( STREQ(key, "end") ) {
         return strunicode(0x2198);
     }
-    if( STREQ(key, "Page Up") ) {
+    if( STREQ(key, "page up") ) {
         return strunicode(0x21de);
     }
-    if( STREQ(key, "Page Down") ) {
+    if( STREQ(key, "page down") ) {
         return strunicode(0x21df);
     }
-    if( STREQ(key, "F1") ) {
+    if( STREQ(key, "f1") ) {
         return strunicode(0xf704);
     }
-    if( STREQ(key, "F2") ) {
+    if( STREQ(key, "f2") ) {
         return strunicode(0xf705);
     }
-    if( STREQ(key, "F3") ) {
+    if( STREQ(key, "f3") ) {
         return strunicode(0xf706);
     }
-    if( STREQ(key, "F4") ) {
+    if( STREQ(key, "f4") ) {
         return strunicode(0xf707);
     }
-    if( STREQ(key, "F5") ) {
+    if( STREQ(key, "f5") ) {
         return strunicode(0xf708);
     }
-    if( STREQ(key, "F6") ) {
+    if( STREQ(key, "f6") ) {
         return strunicode(0xf709);
     }
-    if( STREQ(key, "F7") ) {
+    if( STREQ(key, "f7") ) {
         return strunicode(0xf70a);
     }
-    if( STREQ(key, "F8") ) {
+    if( STREQ(key, "f8") ) {
         return strunicode(0xf70b);
     }
-    if( STREQ(key, "F9") ) {
+    if( STREQ(key, "f9") ) {
         return strunicode(0xf70c);
     }
-    if( STREQ(key, "F10") ) {
+    if( STREQ(key, "f10") ) {
         return strunicode(0xf70d);
     }
-    if( STREQ(key, "F11") ) {
+    if( STREQ(key, "f11") ) {
         return strunicode(0xf70e);
     }
-    if( STREQ(key, "F12") ) {
+    if( STREQ(key, "f12") ) {
         return strunicode(0xf70f);
     }
-    if( STREQ(key, "F13") ) {
+    if( STREQ(key, "f13") ) {
         return strunicode(0xf710);
     }
-    if( STREQ(key, "F14") ) {
+    if( STREQ(key, "f14") ) {
         return strunicode(0xf711);
     }
-    if( STREQ(key, "F15") ) {
+    if( STREQ(key, "f15") ) {
         return strunicode(0xf712);
     }
-    if( STREQ(key, "F16") ) {
+    if( STREQ(key, "f16") ) {
         return strunicode(0xf713);
     }
-    if( STREQ(key, "F17") ) {
+    if( STREQ(key, "f17") ) {
         return strunicode(0xf714);
     }
-    if( STREQ(key, "F18") ) {
+    if( STREQ(key, "f18") ) {
         return strunicode(0xf715);
     }
-    if( STREQ(key, "F19") ) {
+    if( STREQ(key, "f19") ) {
         return strunicode(0xf716);
     }
-    if( STREQ(key, "F20") ) {
+    if( STREQ(key, "f20") ) {
         return strunicode(0xf717);
     }
-    if( STREQ(key, "F21") ) {
+    if( STREQ(key, "f21") ) {
         return strunicode(0xf718);
     }
-    if( STREQ(key, "F22") ) {
+    if( STREQ(key, "f22") ) {
         return strunicode(0xf719);
     }
-    if( STREQ(key, "F23") ) {
+    if( STREQ(key, "f23") ) {
         return strunicode(0xf71a);
     }
-    if( STREQ(key, "F24") ) {
+    if( STREQ(key, "f24") ) {
         return strunicode(0xf71b);
     }
-    if( STREQ(key, "F25") ) {
+    if( STREQ(key, "f25") ) {
         return strunicode(0xf71c);
     }
-    if( STREQ(key, "F26") ) {
+    if( STREQ(key, "f26") ) {
         return strunicode(0xf71d);
     }
-    if( STREQ(key, "F27") ) {
+    if( STREQ(key, "f27") ) {
         return strunicode(0xf71e);
     }
-    if( STREQ(key, "F28") ) {
+    if( STREQ(key, "f28") ) {
         return strunicode(0xf71f);
     }
-    if( STREQ(key, "F29") ) {
+    if( STREQ(key, "f29") ) {
         return strunicode(0xf720);
     }
-    if( STREQ(key, "F30") ) {
+    if( STREQ(key, "f30") ) {
         return strunicode(0xf721);
     }
-    if( STREQ(key, "F31") ) {
+    if( STREQ(key, "f31") ) {
         return strunicode(0xf722);
     }
-    if( STREQ(key, "F32") ) {
+    if( STREQ(key, "f32") ) {
         return strunicode(0xf723);
     }
-    if( STREQ(key, "F33") ) {
+    if( STREQ(key, "f33") ) {
         return strunicode(0xf724);
     }
-    if( STREQ(key, "F34") ) {
+    if( STREQ(key, "f34") ) {
         return strunicode(0xf725);
     }
-    if( STREQ(key, "F35") ) {
+    if( STREQ(key, "f35") ) {
         return strunicode(0xf726);
     }
 //  if( STREQ(key, "Insert") ) {
@@ -336,7 +336,7 @@ id processAcceleratorKey(const char *key) {
 //  if( STREQ(key, "ScrollLock") ) {
 //	return strunicode(0xf72f);
 //  }
-    if( STREQ(key, "NumLock") ) {
+    if( STREQ(key, "numLock") ) {
         return strunicode(0xf739);
     }
 
@@ -509,19 +509,19 @@ unsigned long parseModifiers(const char **modifiers) {
     int count = 0;
     while( thisModifier != NULL ) {
         // Determine flags
-        if( STREQ(thisModifier, "CmdOrCtrl") ) {
+        if( STREQ(thisModifier, "cmdorctrl") ) {
             result |= NSEventModifierFlagCommand;
         }
-        if( STREQ(thisModifier, "OptionOrAlt") ) {
+        if( STREQ(thisModifier, "optionoralt") ) {
             result |= NSEventModifierFlagOption;
         }
-        if( STREQ(thisModifier, "Shift") ) {
+        if( STREQ(thisModifier, "shift") ) {
             result |= NSEventModifierFlagShift;
         }
-        if( STREQ(thisModifier, "Super") ) {
+        if( STREQ(thisModifier, "super") ) {
             result |= NSEventModifierFlagCommand;
         }
-        if( STREQ(thisModifier, "Control") ) {
+        if( STREQ(thisModifier, "control") ) {
             result |= NSEventModifierFlagControl;
         }
         count++;

v2/pkg/menu/keys/keys.go

@@ -1,5 +1,10 @@
 package keys
 
+import (
+	"fmt"
+	"strings"
+)
+
 // Modifier is actually a string
 type Modifier string
 
@@ -16,6 +21,23 @@ const (
 	ControlKey Modifier = "Control"
 )
 
+var modifierMap = map[string]Modifier{
+	"cmdorctrl":   CmdOrCtrlKey,
+	"optionoralt": OptionOrAltKey,
+	"shift":       ShiftKey,
+	"super":       SuperKey,
+	"ctrl":        ControlKey,
+}
+
+func parseModifier(text string) (*Modifier, error) {
+	result, valid := modifierMap[text]
+	if !valid {
+		return nil, fmt.Errorf("'%s' is not a valid modifier", text)
+	}
+
+	return &result, nil
+}
+
 // Accelerator holds the keyboard shortcut for a menu item
 type Accelerator struct {
 	Key       string
@@ -25,14 +47,14 @@ type Accelerator struct {
 // Key creates a standard key Accelerator
 func Key(key string) *Accelerator {
 	return &Accelerator{
-		Key: key,
+		Key: strings.ToLower(key),
 	}
 }
 
 // CmdOrCtrl creates a 'CmdOrCtrl' Accelerator
 func CmdOrCtrl(key string) *Accelerator {
 	return &Accelerator{
-		Key:       key,
+		Key:       strings.ToLower(key),
 		Modifiers: []Modifier{CmdOrCtrlKey},
 	}
 }
@@ -40,7 +62,7 @@ func CmdOrCtrl(key string) *Accelerator {
 // OptionOrAlt creates a 'OptionOrAlt' Accelerator
 func OptionOrAlt(key string) *Accelerator {
 	return &Accelerator{
-		Key:       key,
+		Key:       strings.ToLower(key),
 		Modifiers: []Modifier{OptionOrAltKey},
 	}
 }
@@ -48,7 +70,7 @@ func OptionOrAlt(key string) *Accelerator {
 // Shift creates a 'Shift' Accelerator
 func Shift(key string) *Accelerator {
 	return &Accelerator{
-		Key:       key,
+		Key:       strings.ToLower(key),
 		Modifiers: []Modifier{ShiftKey},
 	}
 }
@@ -56,7 +78,7 @@ func Shift(key string) *Accelerator {
 // Control creates a 'Control' Accelerator
 func Control(key string) *Accelerator {
 	return &Accelerator{
-		Key:       key,
+		Key:       strings.ToLower(key),
 		Modifiers: []Modifier{ControlKey},
 	}
 }
@@ -64,7 +86,7 @@ func Control(key string) *Accelerator {
 // Super creates a 'Super' Accelerator
 func Super(key string) *Accelerator {
 	return &Accelerator{
-		Key:       key,
+		Key:       strings.ToLower(key),
 		Modifiers: []Modifier{SuperKey},
 	}
 }

v2/pkg/menu/keys/parser.go

@@ -0,0 +1,90 @@
+package keys
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/leaanthony/slicer"
+)
+
+var namedKeys = slicer.String([]string{"backspace", "tab", "return", "escape", "left", "right", "up", "down", "space", "delete", "home", "end", "page up", "page down", "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23", "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", "f32", "f33", "f34", "f35", "numlock"})
+
+func parseKey(key string) (string, bool) {
+
+	// Lowercase!
+	key = strings.ToLower(key)
+
+	// Check special case
+	if key == "plus" {
+		return "+", true
+	}
+
+	// Handle named keys
+	if namedKeys.Contains(key) {
+		return key, true
+	}
+
+	// Check we only have a single character
+	if len(key) != 1 {
+		return "", false
+	}
+
+	runeKey := rune(key[0])
+
+	// This may be too inclusive
+	if strconv.IsPrint(runeKey) {
+		return key, true
+	}
+
+	return "", false
+
+}
+
+func Parse(shortcut string) (*Accelerator, error) {
+
+	var result Accelerator
+
+	// Split the shortcut by +
+	components := strings.Split(shortcut, "+")
+
+	// If we only have one it should be a key
+	// We require components
+	if len(components) == 0 {
+		return nil, fmt.Errorf("no components given to validateComponents")
+	}
+
+	// Keep track of modifiers we have processed
+	var modifiersProcessed slicer.StringSlicer
+
+	// Check components
+	for index, component := range components {
+
+		// If last component
+		if index == len(components)-1 {
+			processedkey, validKey := parseKey(component)
+			if !validKey {
+				return nil, fmt.Errorf("'%s' is not a valid key", component)
+			}
+			result.Key = processedkey
+			continue
+		}
+
+		// Not last component - needs to be modifier
+		lowercaseComponent := strings.ToLower(component)
+		thisModifier, valid := modifierMap[lowercaseComponent]
+		if !valid {
+			return nil, fmt.Errorf("'%s' is not a valid modifier", component)
+		}
+		// Needs to be unique
+		if modifiersProcessed.Contains(lowercaseComponent) {
+			return nil, fmt.Errorf("Modifier '%s' is defined twice for shortcut: %s", component, shortcut)
+		}
+
+		// Save this data
+		result.Modifiers = append(result.Modifiers, thisModifier)
+		modifiersProcessed.Add(lowercaseComponent)
+	}
+
+	return &result, nil
+}

v2/pkg/menu/keys/parser_test.go

@@ -0,0 +1,38 @@
+package keys
+
+import (
+	"testing"
+
+	"github.com/matryer/is"
+)
+
+func TestParse(t *testing.T) {
+
+	i := is.New(t)
+
+	type args struct {
+		Input    string
+		Expected *Accelerator
+	}
+
+	gooddata := []args{
+		{"CmdOrCtrl+A", CmdOrCtrl("A")},
+		{"SHIFT+.", Shift(".")},
+		{"CTRL+plus", Control("+")},
+		{"CTRL+SHIFT+escApe", Combo("escape", ControlKey, ShiftKey)},
+		{";", Key(";")},
+		{"Super+Tab", Super("tab")},
+		{"OptionOrAlt+Page Down", OptionOrAlt("Page Down")},
+	}
+	for _, tt := range gooddata {
+		result, err := Parse(tt.Input)
+		i.NoErr(err)
+		i.Equal(result, tt.Expected)
+	}
+	baddata := []string{"CmdOrCrl+A", "SHIT+.", "CTL+plus", "CTRL+SHIF+esApe", "escap", "Sper+Tab", "OptionOrAlt"}
+	for _, d := range baddata {
+		result, err := Parse(d)
+		i.True(err != nil)
+		i.Equal(result, "")
+	}
+}