fix: config errors

feat: test support for Fedora

.chglog/CHANGELOG.tpl.md

@@ -1,42 +0,0 @@
-{{ if .Versions -}}
-<a name="unreleased"></a>
-## [Unreleased]
-
-{{ if .Unreleased.CommitGroups -}}
-{{ range .Unreleased.CommitGroups -}}
-### {{ .Title }}
-{{ range .Commits -}}
-- {{ if .Scope }}**{{ .Scope }}:** {{ end }}{{ .Subject }}
-{{ end }}
-{{ end -}}
-{{ end -}}
-{{ end -}}
-
-{{ range .Versions }}
-<a name="{{ .Tag.Name }}"></a>
-## {{ if .Tag.Previous }}[{{ .Tag.Name }}]{{ else }}{{ .Tag.Name }}{{ end }} - {{ datetime "2006-01-02" .Tag.Date }}
-{{ range .CommitGroups -}}
-### {{ .Title }}
-{{ range .Commits -}}
-- {{ if .Scope }}**{{ .Scope }}:** {{ end }}{{ .Subject }}
-{{ end }}
-{{ end -}}
-
-{{- if .NoteGroups -}}
-{{ range .NoteGroups -}}
-### {{ .Title }}
-{{ range .Notes }}
-{{ .Body }}
-{{ end }}
-{{ end -}}
-{{ end -}}
-{{ end -}}
-
-{{- if .Versions }}
-[Unreleased]: {{ .Info.RepositoryURL }}/compare/{{ $latest := index .Versions 0 }}{{ $latest.Tag.Name }}...HEAD
-{{ range .Versions -}}
-{{ if .Tag.Previous -}}
-[{{ .Tag.Name }}]: {{ $.Info.RepositoryURL }}/compare/{{ .Tag.Previous.Name }}...{{ .Tag.Name }}
-{{ end -}}
-{{ end -}}
-{{ end -}}

.chglog/config.yml

@@ -1,27 +0,0 @@
-style: github
-template: CHANGELOG.tpl.md
-info:
-  title: CHANGELOG
-  repository_url: https://github.com/wailsapp/wails
-options:
-  commits:
-    # filters:
-    #   Type:
-    #     - feat
-    #     - fix
-    #     - perf
-    #     - refactor
-  commit_groups:
-    # title_maps:
-    #   feat: Features
-    #   fix: Bug Fixes
-    #   perf: Performance Improvements
-    #   refactor: Code Refactoring
-  header:
-    pattern: "^(\\w*)\\:\\s(.*)$"
-    pattern_maps:
-      - Type
-      - Subject
-  notes:
-    keywords:
-      - BREAKING CHANGE

.gitignore

@@ -16,4 +16,4 @@ examples/**/example*
 cmd/wails/wails
 .DS_Store
 tmp
-dist
+node_modules

CONTRIBUTORS.md

@@ -13,3 +13,4 @@ Wails is what it is because of the time and effort given by these great people.
 * [Mark Stenglein](https://github.com/ocelotsloth)
 * [admin_3.exe](https://github.com/bh90210)
 * [iceleo-com](https://github.com/iceleo-com)
+* [fallendusk](https://github.com/fallendusk)

README.md

@@ -46,7 +46,7 @@ Make sure you have the xcode command line tools installed. This can be done by r
 
 ### Linux
 
-#### Ubuntu 18.04, Debian 9
+#### Ubuntu 18.04, Debian 9, Zorin 15
 
 `sudo apt install pkg-config build-essential libgtk-3-dev libwebkit2gtk-4.0-dev`
 

app.go

@@ -2,6 +2,13 @@ package wails
 
 import (
 	"github.com/wailsapp/wails/cmd"
+	"github.com/wailsapp/wails/lib/logger"
+	"github.com/wailsapp/wails/runtime/go/runtime"
+	"github.com/wailsapp/wails/lib/renderer"
+	"github.com/wailsapp/wails/lib/binding"
+	"github.com/wailsapp/wails/lib/ipc"
+	"github.com/wailsapp/wails/lib/event"
+	"github.com/wailsapp/wails/lib/interfaces"
 )
 
 // -------------------------------- Compile time Flags ------------------------------
@@ -13,15 +20,15 @@ var BuildMode = cmd.BuildModeProd
 
 // App defines the main application struct
 type App struct {
-	config         *AppConfig      // The Application configuration object
-	cli            *cmd.Cli        // In debug mode, we have a cli
-	renderer       Renderer        // The renderer is what we will render the app to
-	logLevel       string          // The log level of the app
-	ipc            *ipcManager     // Handles the IPC calls
-	log            *CustomLogger   // Logger
-	bindingManager *bindingManager // Handles binding of Go code to renderer
-	eventManager   *eventManager   // Handles all the events
-	runtime        *Runtime        // The runtime object for registered structs
+	config         *AppConfig              // The Application configuration object
+	cli            *cmd.Cli             // In debug mode, we have a cli
+	renderer       interfaces.Renderer    // The renderer is what we will render the app to
+	logLevel       string               // The log level of the app
+	ipc            interfaces.IPCManager          // Handles the IPC calls
+	log            *logger.CustomLogger // Logger
+	bindingManager interfaces.BindingManager     // Handles binding of Go code to renderer
+	eventManager   interfaces.EventManager        // Handles all the events
+	runtime        interfaces.Runtime     // The runtime object for registered structs
 }
 
 // CreateApp creates the application window with the given configuration
@@ -34,14 +41,14 @@ func CreateApp(optionalConfig ...*AppConfig) *App {
 
 	result := &App{
 		logLevel:       "info",
-		renderer:       &webViewRenderer{},
-		ipc:            newIPCManager(),
-		bindingManager: newBindingManager(),
-		eventManager:   newEventManager(),
-		log:            newCustomLogger("App"),
+		renderer:       renderer.NewWebView(),
+		ipc:            ipc.NewManager(),
+		bindingManager: binding.NewManager(),
+		eventManager:   event.NewManager(),
+		log:            logger.NewCustomLogger("App"),
 	}
 
-	appconfig, err := newAppConfig(userConfig)
+	appconfig, err := newConfig(userConfig)
 	if err != nil {
 		result.log.Fatalf("Cannot use custom HTML: %s", err.Error())
 	}
@@ -75,14 +82,14 @@ func (a *App) Run() error {
 func (a *App) start() error {
 
 	// Set the log level
-	setLogLevel(a.logLevel)
+	logger.SetLogLevel(a.logLevel)
 
 	// Log starup
 	a.log.Info("Starting")
 
 	// Check if we are to run in headless mode
 	if BuildMode == cmd.BuildModeBridge {
-		a.renderer = &Headless{}
+		a.renderer = &renderer.Headless{}
 	}
 
 	// Initialise the renderer
@@ -92,16 +99,16 @@ func (a *App) start() error {
 	}
 
 	// Start event manager and give it our renderer
-	a.eventManager.start(a.renderer)
+	a.eventManager.Start(a.renderer)
 
 	// Start the IPC Manager and give it the event manager and binding manager
-	a.ipc.start(a.eventManager, a.bindingManager)
+	a.ipc.Start(a.eventManager, a.bindingManager)
 
 	// Create the runtime
-	a.runtime = newRuntime(a.eventManager, a.renderer)
+	a.runtime = runtime.NewRuntime(a.eventManager, a.renderer)
 
 	// Start binding manager and give it our renderer
-	err = a.bindingManager.start(a.renderer, a.runtime)
+	err = a.bindingManager.Start(a.renderer, a.runtime)
 	if err != nil {
 		return err
 	}
@@ -113,5 +120,5 @@ func (a *App) start() error {
 // Bind allows the user to bind the given object
 // with the application
 func (a *App) Bind(object interface{}) {
-	a.bindingManager.bind(object)
+	a.bindingManager.Bind(object)
 }

cmd/helpers.go

@@ -271,7 +271,7 @@ func InstallBridge(caller string, projectDir string, projectOptions *ProjectOpti
 	}
 
 	// Copy bridge to project
-	bridgeAssets := mewn.Group("../wailsruntimeassets/bridge/")
+	bridgeAssets := mewn.Group("../runtime/bridge/")
 	bridgeFileData := bridgeAssets.Bytes(bridgeFile)
 	bridgeFileTarget := filepath.Join(projectDir, projectOptions.FrontEnd.Dir, projectOptions.FrontEnd.Bridge, "wailsbridge.js")
 	err := fs.CreateFile(bridgeFileTarget, bridgeFileData)

cmd/linux.go

@@ -25,6 +25,10 @@ const (
 	RedHat
 	// Debian distribution
 	Debian
+	// Gentoo distribution
+	Gentoo
+	// Zorin distribution
+	Zorin
 )
 
 // DistroInfo contains all the information relating to a linux distribution
@@ -66,6 +70,12 @@ func GetLinuxDistroInfo() *DistroInfo {
 						result.Distribution = Arch
 					case "Debian":
 						result.Distribution = Debian
+					case "Gentoo":
+						result.Distribution = Gentoo
+					case "Zorin":
+						result.Distribution = Zorin
+					case "Fedora":
+						result.Distribution = RedHat
 					}
 				case "Description":
 					result.Description = value
@@ -113,6 +123,8 @@ func GetLinuxDistroInfo() *DistroInfo {
 			result.Distribution = Arch
 		case "Debian GNU/Linux":
 			result.Distribution = Debian
+		case "Gentoo/Linux":
+			result.Distribution = Gentoo
 		default:
 			result.Distribution = Unknown
 			result.DistributorID = osName
@@ -121,6 +133,17 @@ func GetLinuxDistroInfo() *DistroInfo {
 	return result
 }
 
+// EqueryInstalled uses equery to see if a package is installed
+func EqueryInstalled(packageName string) (bool, error) {
+	program := NewProgramHelper()
+	equery := program.FindProgram("equery")
+	if equery == nil {
+		return false, fmt.Errorf("cannont check dependencies: equery not found")
+	}
+	_, _, exitCode, _ := equery.Run("l", packageName)
+	return exitCode == 0, nil
+}
+
 // DpkgInstalled uses dpkg to see if a package is installed
 func DpkgInstalled(packageName string) (bool, error) {
 	program := NewProgramHelper()

cmd/prerequisites.go

@@ -49,7 +49,7 @@ func getRequiredProgramsLinux() *Prerequisites {
 	result := &Prerequisites{}
 	distroInfo := GetLinuxDistroInfo()
 	switch distroInfo.Distribution {
-	case Ubuntu, Debian:
+	case Ubuntu, Debian, Zorin:
 		result.Add(newPrerequisite("gcc", "Please install with `sudo apt install build-essentials` and try again"))
 		result.Add(newPrerequisite("pkg-config", "Please install with `sudo apt install pkg-config` and try again"))
 		result.Add(newPrerequisite("npm", "Please install with `sudo snap install node --channel=12/stable --classic` and try again"))
@@ -93,9 +93,12 @@ func getRequiredLibrariesLinux() (*Prerequisites, error) {
 	result := &Prerequisites{}
 	distroInfo := GetLinuxDistroInfo()
 	switch distroInfo.Distribution {
-	case Ubuntu:
+	case Ubuntu, Debian, Zorin:
 		result.Add(newPrerequisite("libgtk-3-dev", "Please install with `sudo apt install libgtk-3-dev` and try again"))
 		result.Add(newPrerequisite("libwebkit2gtk-4.0-dev", "Please install with `sudo apt install libwebkit2gtk-4.0-dev` and try again"))
+	case Gentoo:
+		result.Add(newPrerequisite("gtk+:3", "Please install with `sudo emerge gtk+:3` and try again"))
+		result.Add(newPrerequisite("webkit-gtk", "Please install with `sudo emerge webkit-gtk` and try again"))
 	case Arch:
 		result.Add(newPrerequisite("gtk3", "Please install with `sudo pacman -S gtk3` and try again"))
 		result.Add(newPrerequisite("webkit2gtk", "Please install with `sudo pacman -S webkit2gtk` and try again"))

cmd/system.go

@@ -272,7 +272,7 @@ func CheckDependencies(logger *Logger) (bool, error) {
 		distroInfo := GetLinuxDistroInfo()
 		for _, library := range *requiredLibraries {
 			switch distroInfo.Distribution {
-			case Ubuntu, Debian:
+			case Ubuntu, Zorin, Debian:
 				installed, err := DpkgInstalled(library.Name)
 				if err != nil {
 					return false, err
@@ -305,6 +305,17 @@ func CheckDependencies(logger *Logger) (bool, error) {
 				} else {
 					logger.Green("Library '%s' installed.", library.Name)
 				}
+			case Gentoo:
+				installed, err := EqueryInstalled(library.Name)
+				if err != nil {
+					return false, err
+				}
+				if !installed {
+					errors = true
+					logger.Error("Library '%s' not found. %s", library.Name, library.Help)
+				} else {
+					logger.Green("Library '%s' installed.", library.Name)
+				}
 			default:
 				return false, RequestSupportForDistribution(distroInfo, library.Name)
 			}

cmd/version.go

@@ -1,4 +1,4 @@
 package cmd
 
 // Version - Wails version
-const Version = "v0.17.0"
+const Version = "v0.17.4-pre"

cmd/wails/0_setup.go

@@ -96,7 +96,7 @@ func checkLibraries() (errors bool, err error) {
 		distroInfo := cmd.GetLinuxDistroInfo()
 		for _, library := range *requiredLibraries {
 			switch distroInfo.Distribution {
-			case cmd.Ubuntu, cmd.Debian:
+			case cmd.Ubuntu, cmd.Zorin, cmd.Debian:
 				installed, err := cmd.DpkgInstalled(library.Name)
 				if err != nil {
 					return false, err

config.go

@@ -1,11 +1,5 @@
 package wails
 
-import (
-	"strings"
-
-	"github.com/dchest/htmlmin"
-	"github.com/leaanthony/mewn"
-)
 
 // AppConfig is the configuration structure used when creating a Wails App object
 type AppConfig struct {
@@ -18,7 +12,51 @@ type AppConfig struct {
 	Colour           string
 	Resizable        bool
 	DisableInspector bool
-	isHTMLFragment   bool
+}
+
+// GetWidth returns the desired width
+func (a *AppConfig) GetWidth() int {
+	return a.Width
+}
+
+// GetHeight returns the desired height
+func (a *AppConfig) GetHeight() int {
+	return a.Height
+}
+
+// GetTitle returns the desired window title
+func (a *AppConfig) GetTitle() string {
+	return a.Title
+}
+
+// GetDefaultHTML returns the desired window title
+func (a *AppConfig) GetDefaultHTML() string {
+	return a.defaultHTML
+}
+
+// GetResizable returns true if the window should be resizable
+func (a *AppConfig) GetResizable() bool {
+	return a.Resizable
+}
+
+// GetDisableInspector returns true if the inspector should be disabled
+func (a *AppConfig) GetDisableInspector() bool {
+	return a.DisableInspector
+}
+
+// GetColour returns the colour
+func (a *AppConfig) GetColour() string {
+	return a.Colour
+}
+
+// GetCSS returns the user CSS
+func (a *AppConfig) GetCSS() string {
+	return a.CSS
+}
+
+// GetJS returns the user Javascript
+func (a *AppConfig) GetJS() string {
+	return a.JS
 }
 
 func (a *AppConfig) merge(in *AppConfig) error {
@@ -28,32 +66,6 @@ func (a *AppConfig) merge(in *AppConfig) error {
 	if in.Title != "" {
 		a.Title = in.Title
 	}
-	if in.HTML != "" {
-		minified, err := htmlmin.Minify([]byte(in.HTML), &htmlmin.Options{
-			MinifyScripts: true,
-		})
-		if err != nil {
-			return err
-		}
-		inlineHTML := string(minified)
-		inlineHTML = strings.Replace(inlineHTML, "'", "\\'", -1)
-		inlineHTML = strings.Replace(inlineHTML, "\n", " ", -1)
-		a.HTML = strings.TrimSpace(inlineHTML)
-
-		// Deduce whether this is a full html page or a fragment
-		// The document is determined to be a fragment if an HTML
-		// tag exists and is located before the first div tag
-		HTMLTagIndex := strings.Index(a.HTML, "<html")
-		DivTagIndex := strings.Index(a.HTML, "<div")
-
-		if HTMLTagIndex == -1 {
-			a.isHTMLFragment = true
-		} else {
-			if DivTagIndex < HTMLTagIndex {
-				a.isHTMLFragment = true
-			}
-		}
-	}
 
 	if in.Colour != "" {
 		a.Colour = in.Colour
@@ -76,14 +88,13 @@ func (a *AppConfig) merge(in *AppConfig) error {
 }
 
 // Creates the default configuration
-func newAppConfig(userConfig *AppConfig) (*AppConfig, error) {
+func newConfig(userConfig *AppConfig) (*AppConfig, error) {
 	result := &AppConfig{
 		Width:     800,
 		Height:    600,
 		Resizable: true,
 		Title:     "My Wails App",
 		Colour:    "#FFF", // White by default
-		HTML:      mewn.String("./wailsruntimeassets/default/default.html"),
 	}
 
 	if userConfig != nil {

lib/binding/function.go

@@ -1,4 +1,4 @@
-package wails
+package binding
 
 import (
 	"bytes"
@@ -6,6 +6,8 @@ import (
 	"fmt"
 	"reflect"
 	"runtime"
+
+	"github.com/wailsapp/wails/lib/logger"
 )
 
 type boundFunction struct {
@@ -14,7 +16,7 @@ type boundFunction struct {
 	functionType       reflect.Type
 	inputs             []reflect.Type
 	returnTypes        []reflect.Type
-	log                *CustomLogger
+	log                *logger.CustomLogger
 	hasErrorReturnType bool
 }
 
@@ -30,7 +32,7 @@ func newBoundFunction(object interface{}) (*boundFunction, error) {
 		fullName:     name,
 		function:     objectValue,
 		functionType: objectType,
-		log:          newCustomLogger(name),
+		log:          logger.NewCustomLogger(name),
 	}
 
 	err := result.processParameters()
@@ -55,7 +57,7 @@ func (b *boundFunction) processParameters() error {
 			b.inputs[index] = param
 			typ := param
 			index := index
-			b.log.DebugFields("Input param", Fields{
+			b.log.DebugFields("Input param", logger.Fields{
 				"index": index,
 				"name":  name,
 				"kind":  kind,

lib/binding/internal.go

@@ -1,27 +1,33 @@
-package wails
+package binding
 
-import "strings"
-import "fmt"
+import (
+	"fmt"
+	"strings"
 
-type internalMethods struct{
-	log *CustomLogger
-	browser *RuntimeBrowser
+	"github.com/wailsapp/wails/lib/logger"
+	"github.com/wailsapp/wails/lib/messages"
+	"github.com/wailsapp/wails/runtime/go/runtime"
+)
+
+type internalMethods struct {
+	log     *logger.CustomLogger
+	browser *runtime.Browser
 }
 
 func newInternalMethods() *internalMethods {
 	return &internalMethods{
-		log: newCustomLogger("InternalCall"),
-		browser: newRuntimeBrowser(),
+		log:     logger.NewCustomLogger("InternalCall"),
+		browser: runtime.NewBrowser(),
 	}
 }
 
-func (i *internalMethods) processCall(callData *callData) (interface{}, error) {
+func (i *internalMethods) processCall(callData *messages.CallData) (interface{}, error) {
 	if !strings.HasPrefix(callData.BindingName, ".wails.") {
 		return nil, fmt.Errorf("Invalid call signature '%s'", callData.BindingName)
 	}
 
 	// Strip prefix
-	var splitCall = strings.Split(callData.BindingName,".")[2:]
+	var splitCall = strings.Split(callData.BindingName, ".")[2:]
 	if len(splitCall) != 2 {
 		return nil, fmt.Errorf("Invalid call signature '%s'", callData.BindingName)
 	}
@@ -37,14 +43,14 @@ func (i *internalMethods) processCall(callData *callData) (interface{}, error) {
 
 func (i *internalMethods) processBrowserCommand(command string, data interface{}) (interface{}, error) {
 	switch command {
-	case "OpenURL": 
+	case "OpenURL":
 		url := data.(string)
 		// Strip string quotes. Credit: https://stackoverflow.com/a/44222648
 		if url[0] == '"' {
 			url = url[1:]
 		}
-		if i := len(url)-1; url[i] == '"' {
-				url = url[:i]
+		if i := len(url) - 1; url[i] == '"' {
+			url = url[:i]
 		}
 		i.log.Debugf("Calling Browser.OpenURL with '%s'", url)
 		return nil, i.browser.OpenURL(url)
@@ -54,12 +60,12 @@ func (i *internalMethods) processBrowserCommand(command string, data interface{}
 		if filename[0] == '"' {
 			filename = filename[1:]
 		}
-		if i := len(filename)-1; filename[i] == '"' {
-				filename = filename[:i]
+		if i := len(filename) - 1; filename[i] == '"' {
+			filename = filename[:i]
 		}
 		i.log.Debugf("Calling Browser.OpenFile with '%s'", filename)
 		return nil, i.browser.OpenFile(filename)
 	default:
 		return nil, fmt.Errorf("Unknown Browser command '%s'", command)
 	}
-}
+}

lib/binding/manager.go

@@ -1,47 +1,46 @@
-package wails
+package binding
 
 import (
 	"fmt"
 	"reflect"
 	"unicode"
+
+	"github.com/wailsapp/wails/lib/logger"
+	"github.com/wailsapp/wails/lib/messages"
+	"github.com/wailsapp/wails/lib/interfaces"
 )
 
-/**
-
-binding:
- Name() // Full name (package+name)
- Call(params)
-
-**/
-
-type bindingManager struct {
+// Manager handles method binding
+type Manager struct {
 	methods          map[string]*boundMethod
 	functions        map[string]*boundFunction
 	internalMethods  *internalMethods
 	initMethods      []*boundMethod
-	log              *CustomLogger
-	renderer         Renderer
-	runtime          *Runtime // The runtime object to pass to bound structs
+	log              *logger.CustomLogger
+	renderer         interfaces.Renderer
+	runtime          interfaces.Runtime // The runtime object to pass to bound structs
 	objectsToBind    []interface{}
 	bindPackageNames bool // Package name should be considered when binding
 }
 
-func newBindingManager() *bindingManager {
-	result := &bindingManager{
+// NewManager creates a new Manager struct
+func NewManager() interfaces.BindingManager {
+	result := &Manager{
 		methods:         make(map[string]*boundMethod),
 		functions:       make(map[string]*boundFunction),
-		log:             newCustomLogger("Bind"),
+		log:             logger.NewCustomLogger("Bind"),
 		internalMethods: newInternalMethods(),
 	}
 	return result
 }
 
-// Sets flag to indicate package names should be considered when binding
-func (b *bindingManager) BindPackageNames() {
+// BindPackageNames sets a flag to indicate package names should be considered when binding
+func (b *Manager) BindPackageNames() {
 	b.bindPackageNames = true
 }
 
-func (b *bindingManager) start(renderer Renderer, runtime *Runtime) error {
+// Start the binding manager
+func (b *Manager) Start(renderer interfaces.Renderer, runtime interfaces.Runtime) error {
 	b.log.Info("Starting")
 	b.renderer = renderer
 	b.runtime = runtime
@@ -54,7 +53,7 @@ func (b *bindingManager) start(renderer Renderer, runtime *Runtime) error {
 	return err
 }
 
-func (b *bindingManager) initialise() error {
+func (b *Manager) initialise() error {
 
 	var err error
 	// var binding *boundMethod
@@ -92,7 +91,7 @@ func (b *bindingManager) initialise() error {
 }
 
 // bind the given struct method
-func (b *bindingManager) bindMethod(object interface{}) error {
+func (b *Manager) bindMethod(object interface{}) error {
 
 	objectType := reflect.TypeOf(object)
 	baseName := objectType.String()
@@ -142,7 +141,7 @@ func (b *bindingManager) bindMethod(object interface{}) error {
 }
 
 // bind the given function object
-func (b *bindingManager) bindFunction(object interface{}) error {
+func (b *Manager) bindFunction(object interface{}) error {
 
 	newFunction, err := newBoundFunction(object)
 	if err != nil {
@@ -159,18 +158,18 @@ func (b *bindingManager) bindFunction(object interface{}) error {
 	return nil
 }
 
-// Save the given object to be bound at start time
-func (b *bindingManager) bind(object interface{}) {
+// Bind saves the given object to be bound at start time
+func (b *Manager) Bind(object interface{}) {
 	// Store binding
 	b.objectsToBind = append(b.objectsToBind, object)
 }
 
-func (b *bindingManager) processInternalCall(callData *callData) (interface{}, error) {
+func (b *Manager) processInternalCall(callData *messages.CallData) (interface{}, error) {
 	// Strip prefix
 	return b.internalMethods.processCall(callData)
 }
 
-func (b *bindingManager) processFunctionCall(callData *callData) (interface{}, error) {
+func (b *Manager) processFunctionCall(callData *messages.CallData) (interface{}, error) {
 	// Return values
 	var result []reflect.Value
 	var err error
@@ -199,7 +198,7 @@ func (b *bindingManager) processFunctionCall(callData *callData) (interface{}, e
 	return result[0].Interface(), nil
 }
 
-func (b *bindingManager) processMethodCall(callData *callData) (interface{}, error) {
+func (b *Manager) processMethodCall(callData *messages.CallData) (interface{}, error) {
 	// Return values
 	var result []reflect.Value
 	var err error
@@ -233,8 +232,8 @@ func (b *bindingManager) processMethodCall(callData *callData) (interface{}, err
 	return nil, nil
 }
 
-// process an incoming call request
-func (b *bindingManager) processCall(callData *callData) (result interface{}, err error) {
+// ProcessCall processes the given call request
+func (b *Manager) ProcessCall(callData *messages.CallData) (result interface{}, err error) {
 	b.log.Debugf("Wanting to call %s", callData.BindingName)
 
 	// Determine if this is function call or method call by the number of
@@ -272,7 +271,7 @@ func (b *bindingManager) processCall(callData *callData) (result interface{}, er
 
 // callWailsInitMethods calls all of the WailsInit methods that were
 // registered with the runtime object
-func (b *bindingManager) callWailsInitMethods() error {
+func (b *Manager) callWailsInitMethods() error {
 	// Create reflect value for runtime object
 	runtimeValue := reflect.ValueOf(b.runtime)
 	params := []reflect.Value{runtimeValue}

lib/binding/method.go

@@ -1,10 +1,12 @@
-package wails
+package binding
 
 import (
 	"bytes"
 	"encoding/json"
 	"fmt"
 	"reflect"
+
+	"github.com/wailsapp/wails/lib/logger"
 )
 
 type boundMethod struct {
@@ -13,7 +15,7 @@ type boundMethod struct {
 	method             reflect.Value
 	inputs             []reflect.Type
 	returnTypes        []reflect.Type
-	log                *CustomLogger
+	log                *logger.CustomLogger
 	hasErrorReturnType bool // Indicates if there is an error return type
 	isWailsInit        bool
 }
@@ -27,7 +29,7 @@ func newBoundMethod(name string, fullName string, method reflect.Value, objectTy
 	}
 
 	// Setup logger
-	result.log = newCustomLogger(result.fullName)
+	result.log = logger.NewCustomLogger(result.fullName)
 
 	// Check if Parameters are valid
 	err := result.processParameters()
@@ -57,7 +59,7 @@ func (b *boundMethod) processParameters() error {
 			b.inputs[index] = param
 			typ := param
 			index := index
-			b.log.DebugFields("Input param", Fields{
+			b.log.DebugFields("Input param", logger.Fields{
 				"index": index,
 				"name":  name,
 				"kind":  kind,
@@ -166,10 +168,10 @@ func (b *boundMethod) setInputValue(index int, typ reflect.Type, val interface{}
 			reflect.Map,
 			reflect.Ptr,
 			reflect.Slice:
-			logger.Debug("Converting nil to type")
+			b.log.Debug("Converting nil to type")
 			result = reflect.ValueOf(val).Convert(typ)
 		default:
-			logger.Debug("Cannot convert nil to type, returning error")
+			b.log.Debug("Cannot convert nil to type, returning error")
 			return reflect.Zero(typ), fmt.Errorf("Unable to use null value for parameter %d of method %s", index+1, b.fullName)
 		}
 	} else {

lib/event/manager.go

@@ -1,31 +1,34 @@
-package wails
+package event
 
 import (
 	"fmt"
 	"sync"
+	"github.com/wailsapp/wails/lib/logger"
+	"github.com/wailsapp/wails/lib/messages"
+	"github.com/wailsapp/wails/lib/interfaces"
 )
 
-// eventManager handles and processes events
-type eventManager struct {
-	incomingEvents chan *eventData
+// Manager handles and processes events
+type Manager struct {
+	incomingEvents chan *messages.EventData
 	listeners      map[string][]*eventListener
 	exit           bool
-	log            *CustomLogger
-	renderer       Renderer // Messages will be dispatched to the frontend
+	log            *logger.CustomLogger
+	renderer       interfaces.Renderer // Messages will be dispatched to the frontend
 }
 
-// newEventManager creates a new event manager with a 100 event buffer
-func newEventManager() *eventManager {
-	return &eventManager{
-		incomingEvents: make(chan *eventData, 100),
+// NewManager creates a new event manager with a 100 event buffer
+func NewManager() interfaces.EventManager {
+	return &Manager{
+		incomingEvents: make(chan *messages.EventData, 100),
 		listeners:      make(map[string][]*eventListener),
 		exit:           false,
-		log:            newCustomLogger("Events"),
+		log:            logger.NewCustomLogger("Events"),
 	}
 }
 
 // PushEvent places the given event on to the event queue
-func (e *eventManager) PushEvent(eventData *eventData) {
+func (e *Manager) PushEvent(eventData *messages.EventData) {
 	e.incomingEvents <- eventData
 }
 
@@ -40,7 +43,7 @@ type eventListener struct {
 }
 
 // Creates a new event listener from the given callback function
-func (e *eventManager) addEventListener(eventName string, callback func(...interface{}), counter int) error {
+func (e *Manager) addEventListener(eventName string, callback func(...interface{}), counter int) error {
 
 	// Sanity check inputs
 	if callback == nil {
@@ -65,18 +68,19 @@ func (e *eventManager) addEventListener(eventName string, callback func(...inter
 	return nil
 }
 
-func (e *eventManager) On(eventName string, callback func(...interface{})) {
+// On adds a listener for the given event
+func (e *Manager) On(eventName string, callback func(...interface{})) {
 	// Add a persistent eventListener (counter = 0)
 	e.addEventListener(eventName, callback, 0)
 }
 
 // Emit broadcasts the given event to the subscribed listeners
-func (e *eventManager) Emit(eventName string, optionalData ...interface{}) {
-	e.incomingEvents <- &eventData{Name: eventName, Data: optionalData}
+func (e *Manager) Emit(eventName string, optionalData ...interface{}) {
+	e.incomingEvents <- &messages.EventData{Name: eventName, Data: optionalData}
 }
 
-// Starts the event manager's queue processing
-func (e *eventManager) start(renderer Renderer) {
+// Start the event manager's queue processing
+func (e *Manager) Start(renderer interfaces.Renderer) {
 
 	e.log.Info("Starting")
 
@@ -95,7 +99,7 @@ func (e *eventManager) start(renderer Renderer) {
 			// TODO: Listen for application exit
 			select {
 			case event := <-e.incomingEvents:
-				e.log.DebugFields("Got Event", Fields{
+				e.log.DebugFields("Got Event", logger.Fields{
 					"data": event.Data,
 					"name": event.Name,
 				})
@@ -143,6 +147,6 @@ func (e *eventManager) start(renderer Renderer) {
 	wg.Wait()
 }
 
-func (e *eventManager) stop() {
+func (e *Manager) stop() {
 	e.exit = true
 }