feat(scaffolding) folders, templates, rust, c, node WOW

* feat(proton) initial packages for webview and binding-rust
* feat(proton) new folder structure
* chore(compliance) readmes and licenses
* chore(npm) create package.json
* chore(proton) rename packages and create lib/rust
* chore(proton) create templates directory
* feat(rust) rustfmt tab_spaces = 2
* feat(rust) run fmt and fix template structure
* chore(npm) update package
- package name (@quasar/proton)
- node 10, npm 6.6, yarn 1.17.3 (security)
- .gitignore
- .npmignore
- add docs and spec dirs

Signed-off-by: Daniel Thompson-Yvetot <denjell@quasar.dev>

.gitignore

@@ -0,0 +1,61 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+
+# nyc test coverage
+.nyc_output
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (http://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Typescript v1 declaration files
+typings/
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variables file
+.env
+
+/.vs
+.DS_Store
+.Thumbs.db
+*.sublime*
+.idea/
+debug.log
+package-lock.json
+.vscode/settings.json

.npmignore

@@ -0,0 +1,11 @@
+test
+bindings
+docs
+lib
+node_modules
+spec
+ui
+.git
+.github
+.idea
+SECURITY.md

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 Quasar Framework
+Copyright (c) 2017 - Present Quasar Framework Contributors, Boscop, Serge Zaitsev
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -117,7 +117,8 @@ This has been done with our best attempt at due diligence and in
 respect of the original authors. Thankyou - this project would never have
 been possible without your amazing contribution to open-source and we are
 honoured to carry the torch further. Of special note:
-- [zserge](https://github.com/zserge) for the original webview approach
+- [zserge](https://github.com/zserge) for the original webview approach and 
+go bindings
 - [Boscop](https://github.com/Boscop) for the Rust Bindings
 
 ## Documentation
@@ -149,13 +150,9 @@ Thank you to all the people who already <a href="https://github.com/quasarframew
 quasarframework/proton is following [Semantic Versioning 2.0](https://semver.org/).
 
 ## Licenses
-Code: (c) 2019 - Daniel Thompson-Yvetot, Razvan Stoenescu, Lucas Nogueira.
-MIT and where applicable Apache
+Code: (c) 2019 - Daniel Thompson-Yvetot, Razvan Stoenescu, Lucas Nogueira, Boscop, Serge Zaitsev.
+MIT
 
 Logo: CC-BY-NC-ND
 - Original Proton Logo Design by [Daniel Thompson-Yvetot](https://github.com/nothingismagick)
 - Based on the prior work by [Emanuele Bertoldi](https://github.com/zuck)
-
-Note: This license notice will not be complete until we have performed an 
-upstream audit. If you feel that your name should be listed here, please
-create a PR to this file and provide references so we can fact-check. Thanks!

bindings/go/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Serge Zaitsev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bindings/go/README.md

@@ -0,0 +1 @@
+# go-bindings

bindings/go/proton.go

@@ -0,0 +1,572 @@
+//
+// Package proton implements Go bindings to Proton UI.
+//
+// Bindings closely repeat the C APIs and include both, a simplified
+// single-function API to just open a full-screen webview window, and a more
+// advanced and featureful set of APIs, including Go-to-JavaScript bindings.
+//
+// The library uses gtk-webkit, Cocoa/Webkit and MSHTML (IE8..11) as a browser
+// engine and supports Linux, MacOS and Windows 7..10 respectively.
+//
+package proton
+
+/*
+#cgo linux openbsd freebsd CFLAGS: -DWEBVIEW_GTK=1
+#cgo linux openbsd freebsd pkg-config: gtk+-3.0 webkit2gtk-4.0
+
+#cgo windows CFLAGS: -DWEBVIEW_WINAPI=1
+#cgo windows LDFLAGS: -lole32 -lcomctl32 -loleaut32 -luuid -lgdi32
+
+#cgo darwin CFLAGS: -DWEBVIEW_COCOA=1 
+#cgo darwin LDFLAGS: -framework WebKit
+
+#include <stdlib.h>
+#include <stdint.h>
+#define WEBVIEW_STATIC
+#define WEBVIEW_IMPLEMENTATION
+#include "webview.h"
+
+extern void _webviewExternalInvokeCallback(void *, void *);
+
+static inline void CgoWebViewFree(void *w) {
+	free((void *)((struct webview *)w)->title);
+	free((void *)((struct webview *)w)->url);
+	free(w);
+}
+
+static inline void *CgoWebViewCreate(int width, int height, char *title, char *url, int resizable, int debug) {
+	struct webview *w = (struct webview *) calloc(1, sizeof(*w));
+	w->width = width;
+	w->height = height;
+	w->title = title;
+	w->url = url;
+	w->resizable = resizable;
+	w->debug = debug;
+	w->external_invoke_cb = (webview_external_invoke_cb_t) _webviewExternalInvokeCallback;
+	if (webview_init(w) != 0) {
+		CgoWebViewFree(w);
+		return NULL;
+	}
+	return (void *)w;
+}
+
+static inline int CgoWebViewLoop(void *w, int blocking) {
+	return webview_loop((struct webview *)w, blocking);
+}
+
+static inline void CgoWebViewTerminate(void *w) {
+	webview_terminate((struct webview *)w);
+}
+
+static inline void CgoWebViewExit(void *w) {
+	webview_exit((struct webview *)w);
+}
+
+static inline void CgoWebViewSetTitle(void *w, char *title) {
+	webview_set_title((struct webview *)w, title);
+}
+
+static inline void CgoWebViewSetFullscreen(void *w, int fullscreen) {
+	webview_set_fullscreen((struct webview *)w, fullscreen);
+}
+
+static inline void CgoWebViewSetColor(void *w, uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
+	webview_set_color((struct webview *)w, r, g, b, a);
+}
+
+static inline void CgoDialog(void *w, int dlgtype, int flags,
+		char *title, char *arg, char *res, size_t ressz) {
+	webview_dialog(w, dlgtype, flags,
+		(const char*)title, (const char*) arg, res, ressz);
+}
+
+static inline int CgoWebViewEval(void *w, char *js) {
+	return webview_eval((struct webview *)w, js);
+}
+
+static inline void CgoWebViewInjectCSS(void *w, char *css) {
+	webview_inject_css((struct webview *)w, css);
+}
+
+extern void _webviewDispatchGoCallback(void *);
+static inline void _webview_dispatch_cb(struct webview *w, void *arg) {
+	_webviewDispatchGoCallback(arg);
+}
+static inline void CgoWebViewDispatch(void *w, uintptr_t arg) {
+	webview_dispatch((struct webview *)w, _webview_dispatch_cb, (void *)arg);
+}
+*/
+import "C"
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"html/template"
+	"log"
+	"reflect"
+	"runtime"
+	"sync"
+	"unicode"
+	"unsafe"
+)
+
+func init() {
+	// Ensure that main.main is called from the main thread
+	runtime.LockOSThread()
+}
+
+// Open is a simplified API to open a single native window with a full-size webview in
+// it. It can be helpful if you want to communicate with the core app using XHR
+// or WebSockets (as opposed to using JavaScript bindings).
+//
+// Window appearance can be customized using title, width, height and resizable parameters.
+// URL must be provided and can user either a http or https protocol, or be a
+// local file:// URL. On some platforms "data:" URLs are also supported
+// (Linux/MacOS).
+func Open(title, url string, w, h int, resizable bool) error {
+	titleStr := C.CString(title)
+	defer C.free(unsafe.Pointer(titleStr))
+	urlStr := C.CString(url)
+	defer C.free(unsafe.Pointer(urlStr))
+	resize := C.int(0)
+	if resizable {
+		resize = C.int(1)
+	}
+
+	r := C.webview(titleStr, urlStr, C.int(w), C.int(h), resize)
+	if r != 0 {
+		return errors.New("failed to create webview")
+	}
+	return nil
+}
+
+// Debug prints a debug string using stderr on Linux/BSD, NSLog on MacOS and
+// OutputDebugString on Windows.
+func Debug(a ...interface{}) {
+	s := C.CString(fmt.Sprint(a...))
+	defer C.free(unsafe.Pointer(s))
+	C.webview_print_log(s)
+}
+
+// Debugf prints a formatted debug string using stderr on Linux/BSD, NSLog on
+// MacOS and OutputDebugString on Windows.
+func Debugf(format string, a ...interface{}) {
+	s := C.CString(fmt.Sprintf(format, a...))
+	defer C.free(unsafe.Pointer(s))
+	C.webview_print_log(s)
+}
+
+// ExternalInvokeCallbackFunc is a function type that is called every time
+// "window.external.invoke()" is called from JavaScript. Data is the only
+// obligatory string parameter passed into the "invoke(data)" function from
+// JavaScript. To pass more complex data serialized JSON or base64 encoded
+// string can be used.
+type ExternalInvokeCallbackFunc func(w WebView, data string)
+
+// Settings is a set of parameters to customize the initial WebView appearance
+// and behavior. It is passed into the webview.New() constructor.
+type Settings struct {
+	// WebView main window title
+	Title string
+	// URL to open in a webview
+	URL string
+	// Window width in pixels
+	Width int
+	// Window height in pixels
+	Height int
+	// Allows/disallows window resizing
+	Resizable bool
+	// Enable debugging tools (Linux/BSD/MacOS, on Windows use Firebug)
+	Debug bool
+	// A callback that is executed when JavaScript calls "window.external.invoke()"
+	ExternalInvokeCallback ExternalInvokeCallbackFunc
+}
+
+// WebView is an interface that wraps the basic methods for controlling the UI
+// loop, handling multithreading and providing JavaScript bindings.
+type WebView interface {
+	// Run() starts the main UI loop until the user closes the webview window or
+	// Terminate() is called.
+	Run()
+	// Loop() runs a single iteration of the main UI.
+	Loop(blocking bool) bool
+	// SetTitle() changes window title. This method must be called from the main
+	// thread only. See Dispatch() for more details.
+	SetTitle(title string)
+	// SetFullscreen() controls window full-screen mode. This method must be
+	// called from the main thread only. See Dispatch() for more details.
+	SetFullscreen(fullscreen bool)
+	// SetColor() changes window background color. This method must be called from
+	// the main thread only. See Dispatch() for more details.
+	SetColor(r, g, b, a uint8)
+	// Eval() evaluates an arbitrary JS code inside the webview. This method must
+	// be called from the main thread only. See Dispatch() for more details.
+	Eval(js string) error
+	// InjectJS() injects an arbitrary block of CSS code using the JS API. This
+	// method must be called from the main thread only. See Dispatch() for more
+	// details.
+	InjectCSS(css string)
+	// Dialog() opens a system dialog of the given type and title. String
+	// argument can be provided for certain dialogs, such as alert boxes. For
+	// alert boxes argument is a message inside the dialog box.
+	Dialog(dlgType DialogType, flags int, title string, arg string) string
+	// Terminate() breaks the main UI loop. This method must be called from the main thread
+	// only. See Dispatch() for more details.
+	Terminate()
+	// Dispatch() schedules some arbitrary function to be executed on the main UI
+	// thread. This may be helpful if you want to run some JavaScript from
+	// background threads/goroutines, or to terminate the app.
+	Dispatch(func())
+	// Exit() closes the window and cleans up the resources. Use Terminate() to
+	// forcefully break out of the main UI loop.
+	Exit()
+	// Bind() registers a binding between a given value and a JavaScript object with the
+	// given name.  A value must be a struct or a struct pointer. All methods are
+	// available under their camel-case names, starting with a lower-case letter,
+	// e.g. "FooBar" becomes "fooBar" in JavaScript.
+	// Bind() returns a function that updates JavaScript object with the current
+	// Go value. You only need to call it if you change Go value asynchronously.
+	Bind(name string, v interface{}) (sync func(), err error)
+}
+
+// DialogType is an enumeration of all supported system dialog types
+type DialogType int
+
+const (
+	// DialogTypeOpen is a system file open dialog
+	DialogTypeOpen DialogType = iota
+	// DialogTypeSave is a system file save dialog
+	DialogTypeSave
+	// DialogTypeAlert is a system alert dialog (message box)
+	DialogTypeAlert
+)
+
+const (
+	// DialogFlagFile is a normal file picker dialog
+	DialogFlagFile = C.WEBVIEW_DIALOG_FLAG_FILE
+	// DialogFlagDirectory is an open directory dialog
+	DialogFlagDirectory = C.WEBVIEW_DIALOG_FLAG_DIRECTORY
+	// DialogFlagInfo is an info alert dialog
+	DialogFlagInfo = C.WEBVIEW_DIALOG_FLAG_INFO
+	// DialogFlagWarning is a warning alert dialog
+	DialogFlagWarning = C.WEBVIEW_DIALOG_FLAG_WARNING
+	// DialogFlagError is an error dialog
+	DialogFlagError = C.WEBVIEW_DIALOG_FLAG_ERROR
+)
+
+var (
+	m     sync.Mutex
+	index uintptr
+	fns   = map[uintptr]func(){}
+	cbs   = map[WebView]ExternalInvokeCallbackFunc{}
+)
+
+type webview struct {
+	w unsafe.Pointer
+}
+
+var _ WebView = &webview{}
+
+func boolToInt(b bool) int {
+	if b {
+		return 1
+	}
+	return 0
+}
+
+// New creates and opens a new webview window using the given settings. The
+// returned object implements the WebView interface. This function returns nil
+// if a window can not be created.
+func New(settings Settings) WebView {
+	if settings.Width == 0 {
+		settings.Width = 640
+	}
+	if settings.Height == 0 {
+		settings.Height = 480
+	}
+	if settings.Title == "" {
+		settings.Title = "WebView"
+	}
+	w := &webview{}
+	w.w = C.CgoWebViewCreate(C.int(settings.Width), C.int(settings.Height),
+		C.CString(settings.Title), C.CString(settings.URL),
+		C.int(boolToInt(settings.Resizable)), C.int(boolToInt(settings.Debug)))
+	m.Lock()
+	if settings.ExternalInvokeCallback != nil {
+		cbs[w] = settings.ExternalInvokeCallback
+	} else {
+		cbs[w] = func(w WebView, data string) {}
+	}
+	m.Unlock()
+	return w
+}
+
+func (w *webview) Loop(blocking bool) bool {
+	block := C.int(0)
+	if blocking {
+		block = 1
+	}
+	return C.CgoWebViewLoop(w.w, block) == 0
+}
+
+func (w *webview) Run() {
+	for w.Loop(true) {
+	}
+}
+
+func (w *webview) Exit() {
+	C.CgoWebViewExit(w.w)
+}
+
+func (w *webview) Dispatch(f func()) {
+	m.Lock()
+	for ; fns[index] != nil; index++ {
+	}
+	fns[index] = f
+	m.Unlock()
+	C.CgoWebViewDispatch(w.w, C.uintptr_t(index))
+}
+
+func (w *webview) SetTitle(title string) {
+	p := C.CString(title)
+	defer C.free(unsafe.Pointer(p))
+	C.CgoWebViewSetTitle(w.w, p)
+}
+
+func (w *webview) SetColor(r, g, b, a uint8) {
+	C.CgoWebViewSetColor(w.w, C.uint8_t(r), C.uint8_t(g), C.uint8_t(b), C.uint8_t(a))
+}
+
+func (w *webview) SetFullscreen(fullscreen bool) {
+	C.CgoWebViewSetFullscreen(w.w, C.int(boolToInt(fullscreen)))
+}
+
+func (w *webview) Dialog(dlgType DialogType, flags int, title string, arg string) string {
+	const maxPath = 4096
+	titlePtr := C.CString(title)
+	defer C.free(unsafe.Pointer(titlePtr))
+	argPtr := C.CString(arg)
+	defer C.free(unsafe.Pointer(argPtr))
+	resultPtr := (*C.char)(C.calloc((C.size_t)(unsafe.Sizeof((*C.char)(nil))), (C.size_t)(maxPath)))
+	defer C.free(unsafe.Pointer(resultPtr))
+	C.CgoDialog(w.w, C.int(dlgType), C.int(flags), titlePtr,
+		argPtr, resultPtr, C.size_t(maxPath))
+	return C.GoString(resultPtr)
+}
+
+func (w *webview) Eval(js string) error {
+	p := C.CString(js)
+	defer C.free(unsafe.Pointer(p))
+	switch C.CgoWebViewEval(w.w, p) {
+	case -1:
+		return errors.New("evaluation failed")
+	}
+	return nil
+}
+
+func (w *webview) InjectCSS(css string) {
+	p := C.CString(css)
+	defer C.free(unsafe.Pointer(p))
+	C.CgoWebViewInjectCSS(w.w, p)
+}
+
+func (w *webview) Terminate() {
+	C.CgoWebViewTerminate(w.w)
+}
+
+//export _webviewDispatchGoCallback
+func _webviewDispatchGoCallback(index unsafe.Pointer) {
+	var f func()
+	m.Lock()
+	f = fns[uintptr(index)]
+	delete(fns, uintptr(index))
+	m.Unlock()
+	f()
+}
+
+//export _webviewExternalInvokeCallback
+func _webviewExternalInvokeCallback(w unsafe.Pointer, data unsafe.Pointer) {
+	m.Lock()
+	var (
+		cb ExternalInvokeCallbackFunc
+		wv WebView
+	)
+	for wv, cb = range cbs {
+		if wv.(*webview).w == w {
+			break
+		}
+	}
+	m.Unlock()
+	cb(wv, C.GoString((*C.char)(data)))
+}
+
+var bindTmpl = template.Must(template.New("").Parse(`
+if (typeof {{.Name}} === 'undefined') {
+	{{.Name}} = {};
+}
+{{ range .Methods }}
+{{$.Name}}.{{.JSName}} = function({{.JSArgs}}) {
+	window.external.invoke(JSON.stringify({scope: "{{$.Name}}", method: "{{.Name}}", params: [{{.JSArgs}}]}));
+};
+{{ end }}
+`))
+
+type binding struct {
+	Value   interface{}
+	Name    string
+	Methods []methodInfo
+}
+
+func newBinding(name string, v interface{}) (*binding, error) {
+	methods, err := getMethods(v)
+	if err != nil {
+		return nil, err
+	}
+	return &binding{Name: name, Value: v, Methods: methods}, nil
+}
+
+func (b *binding) JS() (string, error) {
+	js := &bytes.Buffer{}
+	err := bindTmpl.Execute(js, b)
+	return js.String(), err
+}
+
+func (b *binding) Sync() (string, error) {
+	js, err := json.Marshal(b.Value)
+	if err == nil {
+		return fmt.Sprintf("%[1]s.data=%[2]s;if(%[1]s.render){%[1]s.render(%[2]s);}", b.Name, string(js)), nil
+	}
+	return "", err
+}
+
+func (b *binding) Call(js string) bool {
+	type rpcCall struct {
+		Scope  string        `json:"scope"`
+		Method string        `json:"method"`
+		Params []interface{} `json:"params"`
+	}
+
+	rpc := rpcCall{}
+	if err := json.Unmarshal([]byte(js), &rpc); err != nil {
+		return false
+	}
+	if rpc.Scope != b.Name {
+		return false
+	}
+	var mi *methodInfo
+	for i := 0; i < len(b.Methods); i++ {
+		if b.Methods[i].Name == rpc.Method {
+			mi = &b.Methods[i]
+			break
+		}
+	}
+	if mi == nil {
+		return false
+	}
+	args := make([]reflect.Value, mi.Arity(), mi.Arity())
+	for i := 0; i < mi.Arity(); i++ {
+		val := reflect.ValueOf(rpc.Params[i])
+		arg := mi.Value.Type().In(i)
+		u := reflect.New(arg)
+		if b, err := json.Marshal(val.Interface()); err == nil {
+			if err = json.Unmarshal(b, u.Interface()); err == nil {
+				args[i] = reflect.Indirect(u)
+			}
+		}
+		if !args[i].IsValid() {
+			return false
+		}
+	}
+	mi.Value.Call(args)
+	return true
+}
+
+type methodInfo struct {
+	Name  string
+	Value reflect.Value
+}
+
+func (mi methodInfo) Arity() int { return mi.Value.Type().NumIn() }
+
+func (mi methodInfo) JSName() string {
+	r := []rune(mi.Name)
+	if len(r) > 0 {
+		r[0] = unicode.ToLower(r[0])
+	}
+	return string(r)
+}
+
+func (mi methodInfo) JSArgs() (js string) {
+	for i := 0; i < mi.Arity(); i++ {
+		if i > 0 {
+			js = js + ","
+		}
+		js = js + fmt.Sprintf("a%d", i)
+	}
+	return js
+}
+
+func getMethods(obj interface{}) ([]methodInfo, error) {
+	p := reflect.ValueOf(obj)
+	v := reflect.Indirect(p)
+	t := reflect.TypeOf(obj)
+	if t == nil {
+		return nil, errors.New("object can not be nil")
+	}
+	k := t.Kind()
+	if k == reflect.Ptr {
+		k = v.Type().Kind()
+	}
+	if k != reflect.Struct {
+		return nil, errors.New("must be a struct or a pointer to a struct")
+	}
+
+	methods := []methodInfo{}
+	for i := 0; i < t.NumMethod(); i++ {
+		method := t.Method(i)
+		if !unicode.IsUpper([]rune(method.Name)[0]) {
+			continue
+		}
+		mi := methodInfo{
+			Name:  method.Name,
+			Value: p.MethodByName(method.Name),
+		}
+		methods = append(methods, mi)
+	}
+
+	return methods, nil
+}
+
+func (w *webview) Bind(name string, v interface{}) (sync func(), err error) {
+	b, err := newBinding(name, v)
+	if err != nil {
+		return nil, err
+	}
+	js, err := b.JS()
+	if err != nil {
+		return nil, err
+	}
+	sync = func() {
+		if js, err := b.Sync(); err != nil {
+			log.Println(err)
+		} else {
+			w.Eval(js)
+		}
+	}
+
+	m.Lock()
+	cb := cbs[w]
+	cbs[w] = func(w WebView, data string) {
+		if ok := b.Call(data); ok {
+			sync()
+		} else {
+			cb(w, data)
+		}
+	}
+	m.Unlock()
+
+	w.Eval(js)
+	sync()
+	return sync, nil
+}

bindings/go/proton_test.go

@@ -0,0 +1,97 @@
+package proton
+
+import (
+	"image"
+	"testing"
+)
+
+type foo struct {
+	Result interface{}
+}
+
+func (f *foo) Foo1(a int, b float32) {
+	f.Result = float64(a) + float64(b)
+}
+func (f *foo) Foo2(a []int, b [3]float32, c map[int]int) {
+	f.Result = map[string]interface{}{"a": a, "b": b, "c": c}
+}
+func (f *foo) Foo3(a []image.Point, b struct{ Z int }) {
+	f.Result = map[string]interface{}{"a": a, "b": b}
+}
+
+func TestBadBinding(t *testing.T) {
+	x := 123
+	for _, v := range []interface{}{
+		nil,
+		true,
+		123,
+		123.4,
+		"hello",
+		'a',
+		make(chan struct{}, 0),
+		func() {},
+		map[string]string{},
+		[]int{},
+		[3]int{0, 0, 0},
+		&x,
+	} {
+		if _, err := newBinding("test", v); err == nil {
+			t.Errorf("should return an error: %#v", v)
+		}
+	}
+}
+
+func TestBindingCall(t *testing.T) {
+	foo := &foo{}
+	b, err := newBinding("test", foo)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Run("Primitives", func(t *testing.T) {
+		if !b.Call(`{"scope":"test","method":"Foo1","params":[3,4.5]}`) {
+			t.Fatal()
+		}
+		if foo.Result.(float64) != 7.5 {
+			t.Fatal(foo)
+		}
+	})
+
+	t.Run("Collections", func(t *testing.T) {
+		// Call with slices, arrays and maps
+		if !b.Call(`{"scope":"test","method":"Foo2","params":[[1,2,3],[4.5,4.6,4.7],{"1":2,"3":4}]}`) {
+			t.Fatal()
+		}
+		m := foo.Result.(map[string]interface{})
+		if ints := m["a"].([]int); ints[0] != 1 || ints[1] != 2 || ints[2] != 3 {
+			t.Fatal(foo)
+		}
+		if floats := m["b"].([3]float32); floats[0] != 4.5 || floats[1] != 4.6 || floats[2] != 4.7 {
+			t.Fatal(foo)
+		}
+		if dict := m["c"].(map[int]int); len(dict) != 2 || dict[1] != 2 || dict[3] != 4 {
+			t.Fatal(foo)
+		}
+	})
+
+	t.Run("Structs", func(t *testing.T) {
+		if !b.Call(`{"scope":"test","method":"Foo3","params":[[{"X":1,"Y":2},{"X":3,"Y":4}],{"Z":42}]}`) {
+			t.Fatal()
+		}
+		m := foo.Result.(map[string]interface{})
+		if p := m["a"].([]image.Point); p[0].X != 1 || p[0].Y != 2 || p[1].X != 3 || p[1].Y != 4 {
+			t.Fatal(foo)
+		}
+		if z := m["b"].(struct{ Z int }); z.Z != 42 {
+			t.Fatal(foo)
+		}
+	})
+
+	t.Run("Errors", func(t *testing.T) {
+		if b.Call(`{"scope":"foo"}`) || b.Call(`{"scope":"test", "method":"Bar"}`) {
+			t.Fatal()
+		}
+		if b.Call(`{"scope":"test","method":"Foo1","params":["3",4.5]}`) {
+			t.Fatal()
+		}
+	})
+}

bindings/rust/.gitignore

@@ -0,0 +1,4 @@
+target/
+**/*.rs.bk
+Cargo.lock
+.idea

bindings/rust/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "proton-ui"
+version = "0.1.0"
+authors = ["Boscop", "rstoenescu", "nothingismagick", "lucasfernog"]
+readme = "README.md"
+license = "MIT"
+repository = "https://github.com/quasarframework/proton"
+description = "Rust bindings for proton, a toolchain for building more secure native apps that have tiny binaries and are very fast."
+keywords = ["quasar", "web", "gui", "desktop", "webkit"]
+categories = ["quasar", "gui", "web-programming", "api-bindings", "rendering", "visualization"]
+
+[dependencies]
+urlencoding = "1.0"
+proton-sys = { path = "proton-sys", version = "0.1.0" }
+boxfnonce = "0.1"
+
+[features]
+default = ["V1_30"]
+V1_30 = []
+
+[dev-dependencies]
+serde = "1.0"
+serde_derive = "1.0"
+serde_json = "1.0"

bindings/rust/LICENSE

@@ -0,0 +1,45 @@
+MIT License
+
+Copyright (c) 2018 Boscop
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+----
+
+MIT License
+
+Copyright (c) 2019 Quasar Framework
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bindings/rust/README.md

@@ -0,0 +1 @@
+# rust bindings

bindings/rust/proton-sys/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "proton-sys"
+version = "0.1.0"
+authors = ["Boscop", "rstoenescu", "nothingismagick", "lucasfernog"]
+license = "MIT"
+repository = "https://github.com/quasarframework/proton"
+description = "Rust native ffi bindings for proton UI"
+keywords = ["quasar", "web", "gui", "desktop", "webkit"]
+categories = ["quasar", "gui", "web-programming", "api-bindings", "rendering", "visualization"]
+build = "build.rs"
+links = "proton"
+
+[lib]
+name = "proton_sys"
+path = "lib.rs"
+
+[dependencies]
+bitflags = "1.0"
+
+[build-dependencies]
+cc = "1"
+pkg-config = "0.3"

bindings/rust/proton-sys/build.rs

@@ -0,0 +1,56 @@
+extern crate cc;
+extern crate pkg_config;
+
+use std::{
+    env,
+    path::{Path, PathBuf},
+    process::Command,
+};
+
+fn main() {
+    let proton_path = PathBuf::from("../../../ui");
+
+    let mut build = cc::Build::new();
+
+    build
+        .include(&proton_path)
+        .file("proton.c")
+        .flag_if_supported("-std=c11")
+        .flag_if_supported("-w");
+
+    if env::var("DEBUG").is_err() {
+        build.define("NDEBUG", None);
+    } else {
+        build.define("DEBUG", None);
+    }
+
+    let target = env::var("TARGET").unwrap();
+
+    if target.contains("windows") {
+        build.define("WEBVIEW_WINAPI", None);
+        for &lib in &["ole32", "comctl32", "oleaut32", "uuid", "gdi32"] {
+            println!("cargo:rustc-link-lib={}", lib);
+        }
+    } else if target.contains("linux") || target.contains("bsd") {
+        let webkit = pkg_config::Config::new()
+            .atleast_version("2.8")
+            .probe("webkit2gtk-4.0")
+            .unwrap();
+
+        for path in webkit.include_paths {
+            build.include(path);
+        }
+        build.define("WEBVIEW_GTK", None);
+    } else if target.contains("apple") {
+        build
+            .define("WEBVIEW_COCOA", None)
+            .flag("-x")
+            .flag("objective-c");
+        println!("cargo:rustc-link-lib=framework=Cocoa");
+        println!("cargo:rustc-link-lib=framework=WebKit");
+    } else {
+        panic!("unsupported target");
+    }
+
+    build.compile("proton");
+}

bindings/rust/proton-sys/lib.rs

@@ -0,0 +1,45 @@
+//! Raw FFI bindings to proton UI.
+
+#[macro_use]
+extern crate bitflags;
+
+use std::os::raw::*;
+
+pub enum CWebView {} // opaque type, only used in ffi pointers
+
+type ErasedExternalInvokeFn = extern "C" fn(webview: *mut CWebView, arg: *const c_char);
+type ErasedDispatchFn = extern "C" fn(webview: *mut CWebView, arg: *mut c_void);
+
+#[repr(C)]
+pub enum DialogType {
+	Open  = 0,
+	Save  = 1,
+	Alert = 2,
+}
+
+bitflags! {
+	#[repr(C)]
+	pub struct DialogFlags: u32 {
+		const FILE      = 0b0000;
+		const DIRECTORY = 0b0001;
+		const INFO      = 0b0010;
+		const WARNING   = 0b0100;
+		const ERROR     = 0b0110;
+	}
+}
+
+extern {
+	pub fn wrapper_webview_free(this: *mut CWebView);
+	pub fn wrapper_webview_new(title: *const c_char, url: *const c_char, width: c_int, height: c_int, resizable: c_int, debug: c_int, external_invoke_cb: Option<ErasedExternalInvokeFn>, userdata: *mut c_void) -> *mut CWebView;
+	pub fn webview_loop(this: *mut CWebView, blocking: c_int) -> c_int;
+	pub fn webview_terminate(this: *mut CWebView);
+	pub fn webview_exit(this: *mut CWebView);
+	pub fn wrapper_webview_get_userdata(this: *mut CWebView) -> *mut c_void;
+	pub fn webview_dispatch(this: *mut CWebView, f: Option<ErasedDispatchFn>, arg: *mut c_void);
+	pub fn webview_eval(this: *mut CWebView, js: *const c_char) -> c_int;
+	pub fn webview_inject_css(this: *mut CWebView, css: *const c_char) -> c_int;
+	pub fn webview_set_title(this: *mut CWebView, title: *const c_char);
+	pub fn webview_set_fullscreen(this: *mut CWebView, fullscreen: c_int);
+	pub fn webview_set_color(this: *mut CWebView, red: u8, green: u8, blue: u8, alpha: u8);
+	pub fn webview_dialog(this: *mut CWebView, dialog_type: DialogType, flags: DialogFlags, title: *const c_char, arg: *const c_char, result: *mut c_char, result_size: usize);
+}

bindings/rust/proton-sys/proton.c

@@ -0,0 +1,28 @@
+#define WEBVIEW_IMPLEMENTATION
+#include "proton.h"
+
+void wrapper_webview_free(struct webview* w) {
+	free(w);
+}
+
+struct webview* wrapper_webview_new(const char* title, const char* url, int width, int height, int resizable, int debug, webview_external_invoke_cb_t external_invoke_cb, void* userdata) {
+	struct webview* w = (struct webview*)calloc(1, sizeof(*w));
+	w->width = width;
+	w->height = height;
+	w->title = title;
+	w->url = url;
+	w->resizable = resizable;
+	w->debug = debug;
+	w->external_invoke_cb = external_invoke_cb;
+	w->userdata = userdata;
+	if (webview_init(w) != 0) {
+		wrapper_webview_free(w);
+		return NULL;
+	}
+	return w;
+}
+
+void* wrapper_webview_get_userdata(struct webview* w) {
+	return w->userdata;
+}
+

bindings/rust/rustfmt.toml

@@ -0,0 +1,13 @@
+max_width = 100
+hard_tabs = false
+tab_spaces = 2
+newline_style = "Auto"
+use_small_heuristics = "Default"
+reorder_imports = true
+reorder_modules = true
+remove_nested_parens = true
+edition = "2015"
+merge_derives = true
+use_try_shorthand = false
+use_field_init_shorthand = false
+force_explicit_abi = true

bindings/rust/src/color.rs

@@ -0,0 +1,52 @@
+/// An RGBA color.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub struct Color {
+  pub r: u8,
+  pub g: u8,
+  pub b: u8,
+  pub a: u8,
+}
+
+impl From<(u8, u8, u8, u8)> for Color {
+  fn from(tuple: (u8, u8, u8, u8)) -> Color {
+    Color {
+      r: tuple.0,
+      g: tuple.1,
+      b: tuple.2,
+      a: tuple.3,
+    }
+  }
+}
+
+impl From<(u8, u8, u8)> for Color {
+  fn from(tuple: (u8, u8, u8)) -> Color {
+    Color {
+      r: tuple.0,
+      g: tuple.1,
+      b: tuple.2,
+      a: 255,
+    }
+  }
+}
+
+impl From<[u8; 4]> for Color {
+  fn from(array: [u8; 4]) -> Color {
+    Color {
+      r: array[0],
+      g: array[1],
+      b: array[2],
+      a: array[3],
+    }
+  }
+}
+
+impl From<[u8; 3]> for Color {
+  fn from(array: [u8; 3]) -> Color {
+    Color {
+      r: array[0],
+      g: array[1],
+      b: array[2],
+      a: 255,
+    }
+  }
+}

bindings/rust/src/dialog.rs

@@ -0,0 +1,141 @@
+use ffi::{self, DialogFlags, DialogType};
+use std::{ffi::CString, path::PathBuf};
+use {read_str, WVResult, WebView};
+
+const STR_BUF_SIZE: usize = 4096;
+
+/// A builder for opening a new dialog window.
+#[derive(Debug)]
+pub struct DialogBuilder<'a: 'b, 'b, T: 'a> {
+  webview: &'b mut WebView<'a, T>,
+}
+
+impl<'a: 'b, 'b, T: 'a> DialogBuilder<'a, 'b, T> {
+  /// Creates a new dialog builder for a WebView.
+  pub fn new(webview: &'b mut WebView<'a, T>) -> DialogBuilder<'a, 'b, T> {
+    DialogBuilder { webview }
+  }
+
+  fn dialog(
+    &mut self,
+    title: String,
+    arg: String,
+    dialog_type: DialogType,
+    dialog_flags: DialogFlags,
+  ) -> WVResult<String> {
+    let mut s = [0u8; STR_BUF_SIZE];
+
+    let title_cstr = CString::new(title)?;
+    let arg_cstr = CString::new(arg)?;
+
+    unsafe {
+      ffi::webview_dialog(
+        self.webview.inner,
+        dialog_type,
+        dialog_flags,
+        title_cstr.as_ptr(),
+        arg_cstr.as_ptr(),
+        s.as_mut_ptr() as _,
+        s.len(),
+      );
+    }
+
+    Ok(read_str(&s))
+  }
+
+  /// Opens a new open file dialog and returns the chosen file path.
+  pub fn open_file<S, P>(&mut self, title: S, default_file: P) -> WVResult<Option<PathBuf>>
+  where
+    S: Into<String>,
+    P: Into<PathBuf>,
+  {
+    self
+      .dialog(
+        title.into(),
+        default_file.into().to_string_lossy().into_owned(),
+        DialogType::Open,
+        DialogFlags::FILE,
+      )
+      .map(|path| {
+        if path.is_empty() {
+          None
+        } else {
+          Some(PathBuf::from(path))
+        }
+      })
+  }
+
+  /// Opens a new choose directory dialog as returns the chosen directory path.
+  pub fn choose_directory<S, P>(
+    &mut self,
+    title: S,
+    default_directory: P,
+  ) -> WVResult<Option<PathBuf>>
+  where
+    S: Into<String>,
+    P: Into<PathBuf>,
+  {
+    self
+      .dialog(
+        title.into(),
+        default_directory.into().to_string_lossy().into_owned(),
+        DialogType::Open,
+        DialogFlags::DIRECTORY,
+      )
+      .map(|path| {
+        if path.is_empty() {
+          None
+        } else {
+          Some(PathBuf::from(path))
+        }
+      })
+  }
+
+  /// Opens an info alert dialog.
+  pub fn info<TS, MS>(&mut self, title: TS, message: MS) -> WVResult
+  where
+    TS: Into<String>,
+    MS: Into<String>,
+  {
+    self
+      .dialog(
+        title.into(),
+        message.into(),
+        DialogType::Alert,
+        DialogFlags::INFO,
+      )
+      .map(|_| ())
+  }
+
+  /// Opens a warning alert dialog.
+  pub fn warning<TS, MS>(&mut self, title: TS, message: MS) -> WVResult
+  where
+    TS: Into<String>,
+    MS: Into<String>,
+  {
+    self
+      .dialog(
+        title.into(),
+        message.into(),
+        DialogType::Alert,
+        DialogFlags::WARNING,
+      )
+      .map(|_| ())
+  }
+
+  /// Opens an error alert dialog.
+  pub fn error<TS, MS>(&mut self, title: TS, message: MS) -> WVResult
+  where
+    TS: Into<String>,
+    MS: Into<String>,
+  {
+    self
+      .dialog(
+        title.into(),
+        message.into(),
+        DialogType::Alert,
+        DialogFlags::ERROR,
+      )
+      .map(|_| ())
+  }
+}

bindings/rust/src/error.rs

@@ -0,0 +1,79 @@
+use std::{
+  error,
+  ffi::NulError,
+  fmt::{self, Debug, Display},
+};
+
+pub trait CustomError: Display + Debug + Send + Sync + 'static {}
+
+impl<T: Display + Debug + Send + Sync + 'static> CustomError for T {}
+
+/// A WebView error.
+#[derive(Debug)]
+pub enum Error {
+  /// While attempting to build a WebView instance, a required field was not initialized.
+  UninitializedField(&'static str),
+  /// An error occurred while initializing a WebView instance.
+  Initialization,
+  /// A nul-byte was found in a provided string.
+  NulByte(NulError),
+  /// An error occurred while evaluating JavaScript in a WebView instance.
+  JsEvaluation,
+  /// An error occurred while injecting CSS into a WebView instance.
+  CssInjection,
+  /// Failure to dispatch a closure to a WebView instance via a handle, likely because the
+  /// WebView was dropped.
+  Dispatch,
+  /// An user-specified error occurred. For use inside invoke and dispatch closures.
+  Custom(Box<CustomError>),
+}
+
+impl Error {
+  /// Creates a custom error from a `T: Display + Debug + Send + Sync + 'static`.
+  pub fn custom<E: CustomError>(error: E) -> Error {
+    Error::Custom(Box::new(error))
+  }
+}
+
+impl error::Error for Error {
+  fn cause(&self) -> Option<&error::Error> {
+    match self {
+      Error::NulByte(cause) => Some(cause),
+      _ => None,
+    }
+  }
+
+  #[cfg(feature = "V1_30")]
+  fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+    match self {
+      Error::NulByte(ref cause) => Some(cause),
+      _ => None,
+    }
+  }
+}
+
+impl Display for Error {
+  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    match self {
+      Error::UninitializedField(field) => write!(f, "Required field uninitialized: {}.", field),
+      Error::Initialization => write!(f, "Webview failed to initialize."),
+      Error::NulByte(cause) => write!(f, "{}", cause),
+      Error::JsEvaluation => write!(f, "Failed to evaluate JavaScript."),
+      Error::CssInjection => write!(f, "Failed to inject CSS."),
+      Error::Dispatch => write!(
+        f,
+        "Closure could not be dispatched. WebView was likely dropped."
+      ),
+      Error::Custom(e) => write!(f, "Error: {}", e),
+    }
+  }
+}
+
+/// A WebView result.
+pub type WVResult<T = ()> = Result<T, Error>;
+
+impl From<NulError> for Error {
+  fn from(e: NulError) -> Error {
+    Error::NulByte(e)
+  }
+}

bindings/rust/src/escape.rs

@@ -0,0 +1,81 @@
+use std::fmt::{self, Write};
+
+/// Escape a string to pass it into JavaScript.
+///
+/// # Example
+///
+/// ```rust,no_run
+/// # use web_view::WebView;
+/// # use std::mem;
+/// #
+/// # let mut view: WebView<()> = unsafe { mem::uninitialized() };
+/// #
+/// let string = "Hello, world!";
+///
+/// // Calls the function callback with "Hello, world!" as its parameter.
+///
+/// view.eval(&format!("callback({});", web_view::escape(string)));
+/// ```
+pub fn escape(string: &str) -> Escaper {
+  Escaper(string)
+}
+
+// "All code points may appear literally in a string literal except for the
+// closing quote code points, U+005C (REVERSE SOLIDUS), U+000D (CARRIAGE
+// RETURN), U+2028 (LINE SEPARATOR), U+2029 (PARAGRAPH SEPARATOR), and U+000A
+// (LINE FEED)." - ES6 Specification
+
+pub struct Escaper<'a>(&'a str);
+
+const SPECIAL: &[char] = &[
+  '\n',       // U+000A (LINE FEED)
+  '\r',       // U+000D (CARRIAGE RETURN)
+  '\'',       // U+0027 (APOSTROPHE)
+  '\\',       // U+005C (REVERSE SOLIDUS)
+  '\u{2028}', // U+2028 (LINE SEPARATOR)
+  '\u{2029}', // U+2029 (PARAGRAPH SEPARATOR)
+];
+
+impl<'a> fmt::Display for Escaper<'a> {
+  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    let &Escaper(mut string) = self;
+
+    f.write_char('\'')?;
+
+    while !string.is_empty() {
+      if let Some(i) = string.find(SPECIAL) {
+        if i > 0 {
+          f.write_str(&string[..i])?;
+        }
+
+        let mut chars = string[i..].chars();
+
+        f.write_str(match chars.next().unwrap() {
+          '\n' => "\\n",
+          '\r' => "\\r",
+          '\'' => "\\'",
+          '\\' => "\\\\",
+          '\u{2028}' => "\\u2028",
+          '\u{2029}' => "\\u2029",
+          _ => unreachable!(),
+        })?;
+
+        string = chars.as_str();
+      } else {
+        f.write_str(string)?;
+        break;
+      }
+    }
+
+    f.write_char('\'')?;
+
+    Ok(())
+  }
+}
+
+#[test]
+fn test() {
+  let plain = "ABC \n\r' abc \\  \u{2028}   \u{2029}123";
+  let escaped = escape(plain).to_string();
+  assert!(escaped == "'ABC \\n\\r\\' abc \\\\  \\u2028   \\u2029123'");
+}

bindings/rust/src/lib.rs

@@ -0,0 +1,526 @@
+extern crate boxfnonce;
+extern crate proton_sys as ffi;
+extern crate urlencoding;
+
+mod color;
+mod dialog;
+mod error;
+mod escape;
+pub use color::Color;
+pub use dialog::DialogBuilder;
+pub use error::{CustomError, Error, WVResult};
+pub use escape::escape;
+
+use boxfnonce::SendBoxFnOnce;
+use ffi::*;
+use std::{
+  ffi::{CStr, CString},
+  marker::PhantomData,
+  mem,
+  os::raw::*,
+  sync::{Arc, RwLock, Weak},
+};
+use urlencoding::encode;
+
+/// Content displayable inside a [`WebView`].
+///
+/// # Variants
+///
+/// - `Url` - Content to be fetched from a URL.
+/// - `Html` - A string containing literal HTML.
+///
+/// [`WebView`]: struct.WebView.html
+#[derive(Debug)]
+pub enum Content<T> {
+  Url(T),
+  Html(T),
+}
+
+/// Builder for constructing a [`WebView`] instance.
+///
+/// # Example
+///
+/// ```no_run
+/// extern crate web_view;
+///
+/// use web_view::*;
+///
+/// fn main() {
+///     WebViewBuilder::new()
+///         .title("Minimal webview example")
+///         .content(Content::Url("https://en.m.wikipedia.org/wiki/Main_Page"))
+///         .size(800, 600)
+///         .resizable(true)
+///         .debug(true)
+///         .user_data(())
+///         .invoke_handler(|_webview, _arg| Ok(()))
+///         .build()
+///         .unwrap()
+///         .run()
+///         .unwrap();
+/// }
+/// ```
+///
+/// [`WebView`]: struct.WebView.html
+pub struct WebViewBuilder<'a, T: 'a, I, C> {
+  pub title: &'a str,
+  pub content: Option<Content<C>>,
+  pub width: i32,
+  pub height: i32,
+  pub resizable: bool,
+  pub debug: bool,
+  pub invoke_handler: Option<I>,
+  pub user_data: Option<T>,
+}
+
+impl<'a, T: 'a, I, C> Default for WebViewBuilder<'a, T, I, C>
+where
+  I: FnMut(&mut WebView<T>, &str) -> WVResult + 'a,
+  C: AsRef<str>,
+{
+  fn default() -> Self {
+    #[cfg(debug_assertions)]
+    let debug = true;
+    #[cfg(not(debug_assertions))]
+    let debug = false;
+
+    WebViewBuilder {
+      title: "Application",
+      content: None,
+      width: 800,
+      height: 600,
+      resizable: true,
+      debug,
+      invoke_handler: None,
+      user_data: None,
+    }
+  }
+}
+
+impl<'a, T: 'a, I, C> WebViewBuilder<'a, T, I, C>
+where
+  I: FnMut(&mut WebView<T>, &str) -> WVResult + 'a,
+  C: AsRef<str>,
+{
+  /// Alias for [`WebViewBuilder::default()`].
+  ///
+  /// [`WebViewBuilder::default()`]: struct.WebviewBuilder.html#impl-Default
+  pub fn new() -> Self {
+    WebViewBuilder::default()
+  }
+
+  /// Sets the title of the WebView window.
+  ///
+  /// Defaults to `"Application"`.
+  pub fn title(mut self, title: &'a str) -> Self {
+    self.title = title;
+    self
+  }
+
+  /// Sets the content of the WebView. Either a URL or a HTML string.
+  pub fn content(mut self, content: Content<C>) -> Self {
+    self.content = Some(content);
+    self
+  }
+
+  /// Sets the size of the WebView window.
+  ///
+  /// Defaults to 800 x 600.
+  pub fn size(mut self, width: i32, height: i32) -> Self {
+    self.width = width;
+    self.height = height;
+    self
+  }
+
+  /// Sets the resizability of the WebView window. If set to false, the window cannot be resized.
+  ///
+  /// Defaults to `true`.
+  pub fn resizable(mut self, resizable: bool) -> Self {
+    self.resizable = resizable;
+    self
+  }
+
+  /// Enables or disables debug mode.
+  ///
+  /// Defaults to `true` for debug builds, `false` for release builds.
+  pub fn debug(mut self, debug: bool) -> Self {
+    self.debug = debug;
+    self
+  }
+
+  /// Sets the invoke handler callback. This will be called when a message is received from
+  /// JavaScript.
+  ///
+  /// # Errors
+  ///
+  /// If the closure returns an `Err`, it will be returned on the next call to [`step()`].
+  ///
+  /// [`step()`]: struct.WebView.html#method.step
+  pub fn invoke_handler(mut self, invoke_handler: I) -> Self {
+    self.invoke_handler = Some(invoke_handler);
+    self
+  }
+
+  /// Sets the initial state of the user data. This is an arbitrary value stored on the WebView
+  /// thread, accessible from dispatched closures without synchronization overhead.
+  pub fn user_data(mut self, user_data: T) -> Self {
+    self.user_data = Some(user_data);
+    self
+  }
+
+  /// Validates provided arguments and returns a new WebView if successful.
+  pub fn build(self) -> WVResult<WebView<'a, T>> {
+    macro_rules! require_field {
+      ($name:ident) => {
+        self
+          .$name
+          .ok_or_else(|| Error::UninitializedField(stringify!($name)))?
+      };
+    }
+
+    let title = CString::new(self.title)?;
+    let content = require_field!(content);
+    let url = match content {
+      Content::Url(url) => CString::new(url.as_ref())?,
+      Content::Html(html) => CString::new(format!("data:text/html,{}", encode(html.as_ref())))?,
+    };
+    let user_data = require_field!(user_data);
+    let invoke_handler = require_field!(invoke_handler);
+
+    WebView::new(
+      &title,
+      &url,
+      self.width,
+      self.height,
+      self.resizable,
+      self.debug,
+      user_data,
+      invoke_handler,
+    )
+  }
+
+  /// Validates provided arguments and runs a new WebView to completion, returning the user data.
+  ///
+  /// Equivalent to `build()?.run()`.
+  pub fn run(self) -> WVResult<T> {
+    self.build()?.run()
+  }
+}
+
+/// Constructs a new builder for a [`WebView`].
+///
+/// Alias for [`WebViewBuilder::default()`].
+///
+/// [`WebView`]: struct.Webview.html
+/// [`WebViewBuilder::default()`]: struct.WebviewBuilder.html#impl-Default
+pub fn builder<'a, T, I, C>() -> WebViewBuilder<'a, T, I, C>
+where
+  I: FnMut(&mut WebView<T>, &str) -> WVResult + 'a,
+  C: AsRef<str>,
+{
+  WebViewBuilder::new()
+}
+
+struct UserData<'a, T> {
+  inner: T,
+  live: Arc<RwLock<()>>,
+  invoke_handler: Box<FnMut(&mut WebView<T>, &str) -> WVResult + 'a>,
+  result: WVResult,
+}
+
+/// An owned webview instance.
+///
+/// Construct via a [`WebViewBuilder`].
+///
+/// [`WebViewBuilder`]: struct.WebViewBuilder.html
+#[derive(Debug)]
+pub struct WebView<'a, T: 'a> {
+  inner: *mut CWebView,
+  _phantom: PhantomData<&'a mut T>,
+}
+
+impl<'a, T> WebView<'a, T> {
+  #![cfg_attr(feature = "cargo-clippy", allow(clippy::too_many_arguments))]
+  fn new<I>(
+    title: &CStr,
+    url: &CStr,
+    width: i32,
+    height: i32,
+    resizable: bool,
+    debug: bool,
+    user_data: T,
+    invoke_handler: I,
+  ) -> WVResult<WebView<'a, T>>
+  where
+    I: FnMut(&mut WebView<T>, &str) -> WVResult + 'a,
+  {
+    let user_data = Box::new(UserData {
+      inner: user_data,
+      live: Arc::new(RwLock::new(())),
+      invoke_handler: Box::new(invoke_handler),
+      result: Ok(()),
+    });
+    let user_data_ptr = Box::into_raw(user_data);
+
+    unsafe {
+      let inner = wrapper_webview_new(
+        title.as_ptr(),
+        url.as_ptr(),
+        width,
+        height,
+        resizable as _,
+        debug as _,
+        Some(ffi_invoke_handler::<T>),
+        user_data_ptr as _,
+      );
+
+      if inner.is_null() {
+        Box::<UserData<T>>::from_raw(user_data_ptr);
+        Err(Error::Initialization)
+      } else {
+        Ok(WebView::from_ptr(inner))
+      }
+    }
+  }
+
+  unsafe fn from_ptr(inner: *mut CWebView) -> WebView<'a, T> {
+    WebView {
+      inner,
+      _phantom: PhantomData,
+    }
+  }
+
+  /// Creates a thread-safe [`Handle`] to the `WebView`, from which closures can be dispatched.
+  ///
+  /// [`Handle`]: struct.Handle.html
+  pub fn handle(&self) -> Handle<T> {
+    Handle {
+      inner: self.inner,
+      live: Arc::downgrade(&self.user_data_wrapper().live),
+      _phantom: PhantomData,
+    }
+  }
+
+  fn user_data_wrapper_ptr(&self) -> *mut UserData<'a, T> {
+    unsafe { wrapper_webview_get_userdata(self.inner) as _ }
+  }
+
+  fn user_data_wrapper(&self) -> &UserData<'a, T> {
+    unsafe { &(*self.user_data_wrapper_ptr()) }
+  }
+
+  fn user_data_wrapper_mut(&mut self) -> &mut UserData<'a, T> {
+    unsafe { &mut (*self.user_data_wrapper_ptr()) }
+  }
+
+  /// Borrows the user data immutably.
+  pub fn user_data(&self) -> &T {
+    &self.user_data_wrapper().inner
+  }
+
+  /// Borrows the user data mutably.
+  pub fn user_data_mut(&mut self) -> &mut T {
+    &mut self.user_data_wrapper_mut().inner
+  }
+
+  /// Forces the `WebView` instance to end, without dropping.
+  pub fn terminate(&mut self) {
+    unsafe { webview_terminate(self.inner) }
+  }
+
+  /// Executes the provided string as JavaScript code within the `WebView` instance.
+  pub fn eval(&mut self, js: &str) -> WVResult {
+    let js = CString::new(js)?;
+    let ret = unsafe { webview_eval(self.inner, js.as_ptr()) };
+    if ret != 0 {
+      Err(Error::JsEvaluation)
+    } else {
+      Ok(())
+    }
+  }
+
+  /// Injects the provided string as CSS within the `WebView` instance.
+  pub fn inject_css(&mut self, css: &str) -> WVResult {
+    let css = CString::new(css)?;
+    let ret = unsafe { webview_inject_css(self.inner, css.as_ptr()) };
+    if ret != 0 {
+      Err(Error::CssInjection)
+    } else {
+      Ok(())
+    }
+  }
+
+  /// Sets the color of the title bar.
+  ///
+  /// # Examples
+  ///
+  /// Without specifying alpha (defaults to 255):
+  /// ```ignore
+  /// webview.set_color((123, 321, 213));
+  /// ```
+  ///
+  /// Specifying alpha:
+  /// ```ignore
+  /// webview.set_color((123, 321, 213, 127));
+  /// ```
+  pub fn set_color<C: Into<Color>>(&mut self, color: C) {
+    let color = color.into();
+    unsafe { webview_set_color(self.inner, color.r, color.g, color.b, color.a) }
+  }
+
+  /// Sets the title displayed at the top of the window.
+  ///
+  /// # Errors
+  ///
+  /// If `title` contain a nul byte, returns [`Error::NulByte`].
+  ///
+  /// [`Error::NulByte`]: enum.Error.html#variant.NulByte
+  pub fn set_title(&mut self, title: &str) -> WVResult {
+    let title = CString::new(title)?;
+    unsafe { webview_set_title(self.inner, title.as_ptr()) }
+    Ok(())
+  }
+
+  /// Enables or disables fullscreen.
+  pub fn set_fullscreen(&mut self, fullscreen: bool) {
+    unsafe { webview_set_fullscreen(self.inner, fullscreen as _) };
+  }
+
+  /// Returns a builder for opening a new dialog window.
+  pub fn dialog<'b>(&'b mut self) -> DialogBuilder<'a, 'b, T> {
+    DialogBuilder::new(self)
+  }
+
+  /// Iterates the event loop. Returns `None` if the view has been closed or terminated.
+  pub fn step(&mut self) -> Option<WVResult> {
+    unsafe {
+      match webview_loop(self.inner, 1) {
+        0 => {
+          let closure_result = &mut self.user_data_wrapper_mut().result;
+          match closure_result {
+            Ok(_) => Some(Ok(())),
+            e => Some(mem::replace(e, Ok(()))),
+          }
+        }
+        _ => None,
+      }
+    }
+  }
+
+  /// Runs the event loop to completion and returns the user data.
+  pub fn run(mut self) -> WVResult<T> {
+    loop {
+      match self.step() {
+        Some(Ok(_)) => (),
+        Some(e) => e?,
+        None => return Ok(self.into_inner()),
+      }
+    }
+  }
+
+  /// Consumes the `WebView` and returns ownership of the user data.
+  pub fn into_inner(mut self) -> T {
+    unsafe {
+      let user_data = self._into_inner();
+      mem::forget(self);
+      user_data
+    }
+  }
+
+  unsafe fn _into_inner(&mut self) -> T {
+    let _lock = self
+      .user_data_wrapper()
+      .live
+      .write()
+      .expect("A dispatch channel thread panicked while holding mutex to WebView.");
+
+    let user_data_ptr = self.user_data_wrapper_ptr();
+    webview_exit(self.inner);
+    wrapper_webview_free(self.inner);
+    let user_data = *Box::from_raw(user_data_ptr);
+    user_data.inner
+  }
+}
+
+impl<'a, T> Drop for WebView<'a, T> {
+  fn drop(&mut self) {
+    unsafe {
+      self._into_inner();
+    }
+  }
+}
+
+/// A thread-safe handle to a [`WebView`] instance. Used to dispatch closures onto its task queue.
+///
+/// [`WebView`]: struct.WebView.html
+pub struct Handle<T> {
+  inner: *mut CWebView,
+  live: Weak<RwLock<()>>,
+  _phantom: PhantomData<T>,
+}
+
+impl<T> Handle<T> {
+  /// Schedules a closure to be run on the [`WebView`] thread.
+  ///
+  /// # Errors
+  ///
+  /// Returns [`Error::Dispatch`] if the [`WebView`] has been dropped.
+  ///
+  /// If the closure returns an `Err`, it will be returned on the next call to [`step()`].
+  ///
+  /// [`WebView`]: struct.WebView.html
+  /// [`Error::Dispatch`]: enum.Error.html#variant.Dispatch
+  /// [`step()`]: struct.WebView.html#method.step
+  pub fn dispatch<F>(&self, f: F) -> WVResult
+  where
+    F: FnOnce(&mut WebView<T>) -> WVResult + Send + 'static,
+  {
+    // Abort if WebView has been dropped. Otherwise, keep it alive until closure has been
+    // dispatched.
+    let mutex = self.live.upgrade().ok_or(Error::Dispatch)?;
+    let closure = Box::new(SendBoxFnOnce::new(f));
+    let _lock = mutex.read().map_err(|_| Error::Dispatch)?;
+
+    // Send closure to webview.
+    unsafe {
+      webview_dispatch(
+        self.inner,
+        Some(ffi_dispatch_handler::<T> as _),
+        Box::into_raw(closure) as _,
+      )
+    }
+    Ok(())
+  }
+}
+
+unsafe impl<T> Send for Handle<T> {}
+unsafe impl<T> Sync for Handle<T> {}
+
+fn read_str(s: &[u8]) -> String {
+  let end = s.iter().position(|&b| b == 0).map_or(0, |i| i + 1);
+  match CStr::from_bytes_with_nul(&s[..end]) {
+    Ok(s) => s.to_string_lossy().into_owned(),
+    Err(_) => "".to_string(),
+  }
+}
+
+extern "C" fn ffi_dispatch_handler<T>(webview: *mut CWebView, arg: *mut c_void) {
+  unsafe {
+    let mut handle = mem::ManuallyDrop::new(WebView::<T>::from_ptr(webview));
+    let result = {
+      let callback =
+        Box::<SendBoxFnOnce<'static, (&mut WebView<T>,), WVResult>>::from_raw(arg as _);
+      callback.call(&mut handle)
+    };
+    handle.user_data_wrapper_mut().result = result;
+  }
+}
+
+extern "C" fn ffi_invoke_handler<T>(webview: *mut CWebView, arg: *const c_char) {
+  unsafe {
+    let arg = CStr::from_ptr(arg).to_string_lossy().to_string();
+    let mut handle = mem::ManuallyDrop::new(WebView::<T>::from_ptr(webview));
+    let result = ((*handle.user_data_wrapper_ptr()).invoke_handler)(&mut *handle, &arg);
+    handle.user_data_wrapper_mut().result = result;
+  }
+}

docs/README.md

@@ -0,0 +1 @@
+[WIP]

lib/rust/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "proton"
+version = "0.1.0"
+authors = ["Lucas Fernandes Gonçalves Nogueira <lucas@quasar.dev>"]
+edition = "2018"
+
+[dependencies]
+proton-ui = { path = "../../bindings/rust" }
+serde_json = "1.0.39"
+serde = "1.0"
+serde_derive = "1.0"
+dirs = "1.0"
+ignore = "0.4.7"
+phf = "0.7.21"
+threadpool = "1.7"
+rand = "0.7"
+reqwest = "0.9"
+pbr = "1"
+zip = "0.5.0"
+tempdir = "0.3"
+semver = "0.9"
+tempfile = "3"
+either = "1.5.0"
+tar = "0.4"
+flate2 = "1"
+hyper-old-types = "0.11.0"
+sysinfo = "0.9"

lib/rust/rustfmt.toml

@@ -0,0 +1,13 @@
+max_width = 100
+hard_tabs = false
+tab_spaces = 2
+newline_style = "Auto"
+use_small_heuristics = "Default"
+reorder_imports = true
+reorder_modules = true
+remove_nested_parens = true
+edition = "2015"
+merge_derives = true
+use_try_shorthand = false
+use_field_init_shorthand = false
+force_explicit_abi = true

lib/rust/src/api/cmd.rs

@@ -0,0 +1,40 @@
+#[derive(Deserialize)]
+#[serde(tag = "cmd", rename_all = "camelCase")]
+pub enum Cmd {
+  Init,
+  ReadAsString {
+    path: String,
+    callback: String,
+    error: String,
+  },
+  ReadAsBinary {
+    path: String,
+    callback: String,
+    error: String,
+  },
+  Write {
+    file: String,
+    contents: String,
+    callback: String,
+    error: String,
+  },
+  List {
+    path: String,
+    callback: String,
+    error: String,
+  },
+  ListDirs {
+    path: String,
+    callback: String,
+    error: String,
+  },
+  SetTitle {
+    title: String,
+  },
+  Call {
+    command: String,
+    args: Vec<String>,
+    callback: String,
+    error: String,
+  },
+}

lib/rust/src/api/mod.rs

@@ -0,0 +1,63 @@
+mod cmd;
+
+use proton_ui::WebView;
+
+pub fn handler<T: 'static>(webview: &mut WebView<T>, arg: &str) -> bool {
+  use cmd::Cmd::*;
+  match serde_json::from_str(arg) {
+    Err(_) => false,
+    Ok(command) => {
+      match command {
+        Init => (),
+        ReadAsString {
+          path,
+          callback,
+          error,
+        } => {
+          super::file_system::read_text_file(webview, path, callback, error);
+        }
+        ReadAsBinary {
+          path,
+          callback,
+          error,
+        } => {
+          super::file_system::read_binary_file(webview, path, callback, error);
+        }
+        Write {
+          file,
+          contents,
+          callback,
+          error,
+        } => {
+          super::file_system::write_file(webview, file, contents, callback, error);
+        }
+        ListDirs {
+          path,
+          callback,
+          error,
+        } => {
+          super::file_system::list_dirs(webview, path, callback, error);
+        }
+        List {
+          path,
+          callback,
+          error,
+        } => {
+          super::file_system::list(webview, path, callback, error);
+        }
+        SetTitle { title } => {
+          webview.set_title(&title).unwrap();
+        }
+        Call {
+          command,
+          args,
+          callback,
+          error,
+        } => {
+          super::command::call(webview, command, args, callback, error);
+        }
+      }
+      true
+    }
+  }
+}

lib/rust/src/command.rs

@@ -0,0 +1,78 @@
+use proton_ui::WebView;
+
+use std::process::{Child, Command, Stdio};
+
+use super::run_async;
+
+pub fn get_output(cmd: String, args: Vec<String>, stdout: Stdio) -> Result<String, String> {
+  Command::new(cmd)
+    .args(args)
+    .stdout(stdout)
+    .output()
+    .map_err(|err| err.to_string())
+    .and_then(|output| {
+      if output.status.success() {
+        return Result::Ok(String::from_utf8_lossy(&output.stdout).to_string());
+      } else {
+        return Result::Err(String::from_utf8_lossy(&output.stderr).to_string());
+      }
+    })
+}
+
+// TODO use .exe for windows builds
+pub fn format_command(path: String, command: String) -> String {
+  return format!("{}/./{}", path, command);
+}
+
+pub fn relative_command(command: String) -> Result<String, std::io::Error> {
+  match std::env::current_exe()?.parent() {
+    Some(exe_dir) => return Ok(format_command(exe_dir.display().to_string(), command)),
+    None => {
+      return Err(std::io::Error::new(
+        std::io::ErrorKind::Other,
+        "Could not evaluate executable dir".to_string(),
+      ))
+    }
+  }
+}
+
+// TODO append .exe for windows builds
+pub fn command_path(command: String) -> Result<String, std::io::Error> {
+  match std::env::current_exe()?.parent() {
+    Some(exe_dir) => return Ok(format!("{}/{}", exe_dir.display().to_string(), command)),
+    None => {
+      return Err(std::io::Error::new(
+        std::io::ErrorKind::Other,
+        "Could not evaluate executable dir".to_string(),
+      ))
+    }
+  }
+}
+
+pub fn spawn_relative_command(
+  command: String,
+  args: Vec<String>,
+  stdout: Stdio,
+) -> Result<Child, std::io::Error> {
+  let cmd = relative_command(command)?;
+  Ok(Command::new(cmd).args(args).stdout(stdout).spawn()?)
+}
+
+pub fn call<T: 'static>(
+  webview: &mut WebView<T>,
+  command: String,
+  args: Vec<String>,
+  callback: String,
+  error: String,
+) {
+  run_async(
+    webview,
+    || {
+      get_output(command, args, Stdio::piped())
+        .map_err(|err| format!("`{}`", err))
+        .map(|output| format!("`{}`", output))
+    },
+    callback,
+    error,
+  );
+}

lib/rust/src/dir/mod.rs

@@ -0,0 +1,77 @@
+extern crate dirs;
+extern crate tempfile;
+
+mod utils;
+use ignore::Walk;
+use std::fs;
+use std::fs::metadata;
+use utils::get_dir_name_from_path;
+
+use tempfile::tempdir;
+
+#[derive(Serialize)]
+pub struct DiskEntry {
+  pub path: String,
+  pub is_dir: bool,
+  pub name: String,
+}
+
+fn is_dir(file_name: String) -> Result<bool, String> {
+  match metadata(file_name.to_string()) {
+    Ok(md) => return Result::Ok(md.is_dir()),
+    Err(err) => return Result::Err(err.to_string()),
+  };
+}
+
+pub fn walk_dir(path_copy: String) -> Result<Vec<DiskEntry>, String> {
+  println!("Trying to walk: {}", path_copy.as_str());
+  let mut files_and_dirs: Vec<DiskEntry> = vec![];
+  for result in Walk::new(path_copy) {
+    match result {
+      Ok(entry) => {
+        let display_value = entry.path().display();
+        let _dir_name = display_value.to_string();
+
+        match is_dir(display_value.to_string()) {
+          Ok(flag) => {
+            files_and_dirs.push(DiskEntry {
+              path: display_value.to_string(),
+              is_dir: flag,
+              name: display_value.to_string(),
+            });
+          }
+          Err(_) => {}
+        }
+      }
+      Err(_) => {}
+    }
+  }
+  return Result::Ok(files_and_dirs);
+}
+
+pub fn list_dir_contents(dir_path: &String) -> Result<Vec<DiskEntry>, String> {
+  fs::read_dir(dir_path)
+    .map_err(|err| err.to_string())
+    .and_then(|paths| {
+      let mut dirs: Vec<DiskEntry> = vec![];
+      for path in paths {
+        let dir_path = path.expect("dirpath error").path();
+        let _dir_name = dir_path.display();
+        dirs.push(DiskEntry {
+          path: format!("{}", _dir_name),
+          is_dir: true,
+          name: get_dir_name_from_path(_dir_name.to_string()),
+        });
+      }
+      Ok(dirs)
+    })
+}
+
+pub fn with_temp_dir<F: FnOnce(&tempfile::TempDir) -> ()>(
+  callback: F,
+) -> Result<(), std::io::Error> {
+  let dir = tempdir()?;
+  callback(&dir);
+  dir.close()?;
+  Ok(())
+}

lib/rust/src/dir/utils.rs

@@ -0,0 +1,4 @@
+pub fn get_dir_name_from_path(path: String) -> String {
+  let path_collect: Vec<&str> = path.split("/").collect();
+  return path_collect[path_collect.len() - 1].to_string();
+}

lib/rust/src/file/error.rs

@@ -0,0 +1,46 @@
+use std;
+use zip::result::ZipError;
+
+#[derive(Debug)]
+pub enum Error {
+  Extract(String),
+  Io(std::io::Error),
+  Zip(ZipError),
+}
+
+impl std::fmt::Display for Error {
+  fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    use Error::*;
+    match *self {
+      Extract(ref s) => write!(f, "ExtractError: {}", s),
+      Io(ref e) => write!(f, "IoError: {}", e),
+      Zip(ref e) => write!(f, "ZipError: {}", e),
+    }
+  }
+}
+
+impl std::error::Error for Error {
+  fn description(&self) -> &str {
+    "File Error"
+  }
+
+  fn cause(&self) -> Option<&std::error::Error> {
+    use Error::*;
+    Some(match *self {
+      Io(ref e) => e,
+      _ => return None,
+    })
+  }
+}
+
+impl From<std::io::Error> for Error {
+  fn from(e: std::io::Error) -> Self {
+    Error::Io(e)
+  }
+}
+
+impl From<ZipError> for Error {
+  fn from(e: ZipError) -> Self {
+    Error::Zip(e)
+  }
+}

lib/rust/src/file/extract.rs

@@ -0,0 +1,189 @@
+extern crate either;
+extern crate flate2;
+extern crate tar;
+extern crate zip;
+
+use super::error::*;
+use either::Either;
+use std::fs;
+use std::io;
+use std::path;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum ArchiveFormat {
+  Tar(Option<Compression>),
+  Plain(Option<Compression>),
+  Zip,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Compression {
+  Gz,
+}
+
+#[derive(Debug)]
+pub struct Extract<'a> {
+  source: &'a path::Path,
+  archive_format: Option<ArchiveFormat>,
+}
+
+fn detect_archive_type(path: &path::Path) -> ArchiveFormat {
+  match path.extension() {
+    Some(extension) if extension == std::ffi::OsStr::new("zip") => ArchiveFormat::Zip,
+    Some(extension) if extension == std::ffi::OsStr::new("tar") => ArchiveFormat::Tar(None),
+    Some(extension) if extension == std::ffi::OsStr::new("gz") => match path
+      .file_stem()
+      .map(|e| path::Path::new(e))
+      .and_then(|f| f.extension())
+    {
+      Some(extension) if extension == std::ffi::OsStr::new("tar") => {
+        ArchiveFormat::Tar(Some(Compression::Gz))
+      }
+      _ => ArchiveFormat::Plain(Some(Compression::Gz)),
+    },
+    _ => ArchiveFormat::Plain(None),
+  }
+}
+
+impl<'a> Extract<'a> {
+  /// Create an `Extractor from a source path
+  pub fn from_source(source: &'a path::Path) -> Extract<'a> {
+    Self {
+      source,
+      archive_format: None,
+    }
+  }
+
+  /// Specify an archive format of the source being extracted. If not specified, the
+  /// archive format will determined from the file extension.
+  pub fn archive_format(&mut self, format: ArchiveFormat) -> &mut Self {
+    self.archive_format = Some(format);
+    self
+  }
+
+  fn get_archive_reader(
+    source: fs::File,
+    compression: Option<Compression>,
+  ) -> Either<fs::File, flate2::read::GzDecoder<fs::File>> {
+    match compression {
+      Some(Compression::Gz) => Either::Right(flate2::read::GzDecoder::new(source)),
+      None => Either::Left(source),
+    }
+  }
+
+  /// Extract an entire source archive into a specified path. If the source is a single compressed
+  /// file and not an archive, it will be extracted into a file with the same name inside of
+  /// `into_dir`.
+  pub fn extract_into(&self, into_dir: &path::Path) -> Result<(), Error> {
+    let source = fs::File::open(self.source)?;
+    let archive = self
+      .archive_format
+      .unwrap_or_else(|| detect_archive_type(&self.source));
+
+    match archive {
+      ArchiveFormat::Plain(compression) | ArchiveFormat::Tar(compression) => {
+        let mut reader = Self::get_archive_reader(source, compression);
+
+        match archive {
+          ArchiveFormat::Plain(_) => {
+            match fs::create_dir_all(into_dir) {
+              Ok(_) => (),
+              Err(e) => {
+                if e.kind() != io::ErrorKind::AlreadyExists {
+                  return Err(Error::Io(e));
+                }
+              }
+            }
+            let file_name = self
+              .source
+              .file_name()
+              .ok_or_else(|| Error::Extract("Extractor source has no file-name".into()))?;
+            let mut out_path = into_dir.join(file_name);
+            out_path.set_extension("");
+            let mut out_file = fs::File::create(&out_path)?;
+            io::copy(&mut reader, &mut out_file)?;
+          }
+          ArchiveFormat::Tar(_) => {
+            let mut archive = tar::Archive::new(reader);
+            archive.unpack(into_dir)?;
+          }
+          _ => unreachable!(),
+        };
+      }
+      ArchiveFormat::Zip => {
+        let mut archive = zip::ZipArchive::new(source)?;
+        for i in 0..archive.len() {
+          let mut file = archive.by_index(i)?;
+          let path = into_dir.join(file.name());
+          let mut output = fs::File::create(path)?;
+          io::copy(&mut file, &mut output)?;
+        }
+      }
+    };
+    Ok(())
+  }
+
+  /// Extract a single file from a source and save to a file of the same name in `into_dir`.
+  /// If the source is a single compressed file, it will be saved with the name `file_to_extract`
+  /// in the specified `into_dir`.
+  pub fn extract_file<T: AsRef<path::Path>>(
+    &self,
+    into_dir: &path::Path,
+    file_to_extract: T,
+  ) -> Result<(), Error> {
+    let file_to_extract = file_to_extract.as_ref();
+    let source = fs::File::open(self.source)?;
+    let archive = self
+      .archive_format
+      .unwrap_or_else(|| detect_archive_type(&self.source));
+
+    match archive {
+      ArchiveFormat::Plain(compression) | ArchiveFormat::Tar(compression) => {
+        let mut reader = Self::get_archive_reader(source, compression);
+
+        match archive {
+          ArchiveFormat::Plain(_) => {
+            match fs::create_dir_all(into_dir) {
+              Ok(_) => (),
+              Err(e) => {
+                if e.kind() != io::ErrorKind::AlreadyExists {
+                  return Err(Error::Io(e));
+                }
+              }
+            }
+            let file_name = file_to_extract
+              .file_name()
+              .ok_or_else(|| Error::Extract("Extractor source has no file-name".into()))?;
+            let out_path = into_dir.join(file_name);
+            let mut out_file = fs::File::create(&out_path)?;
+            io::copy(&mut reader, &mut out_file)?;
+          }
+          ArchiveFormat::Tar(_) => {
+            let mut archive = tar::Archive::new(reader);
+            let mut entry = archive
+              .entries()?
+              .filter_map(|e| e.ok())
+              .find(|e| e.path().ok().filter(|p| p == file_to_extract).is_some())
+              .ok_or_else(|| {
+                Error::Extract(format!(
+                  "Could not find the required path in the archive: {:?}",
+                  file_to_extract
+                ))
+              })?;
+            entry.unpack_in(into_dir)?;
+          }
+          _ => {
+            panic!("Unreasonable code");
+          }
+        };
+      }
+      ArchiveFormat::Zip => {
+        let mut archive = zip::ZipArchive::new(source)?;
+        let mut file = archive.by_name(file_to_extract.to_str().unwrap())?;
+        let mut output = fs::File::create(into_dir.join(file.name()))?;
+        io::copy(&mut file, &mut output)?;
+      }
+    };
+    Ok(())
+  }
+}

lib/rust/src/file/file_move.rs

@@ -0,0 +1,62 @@
+use std::fs;
+use std::path;
+
+use super::error::*;
+
+/// Moves a file from the given path to the specified destination.
+///
+/// `source` and `dest` must be on the same filesystem.
+/// If `replace_using_temp` is specified, the destination file will be
+/// replaced using the given temporary path.
+///
+/// * Errors:
+///     * Io - copying / renaming
+#[derive(Debug)]
+pub struct Move<'a> {
+  source: &'a path::Path,
+  temp: Option<&'a path::Path>,
+}
+impl<'a> Move<'a> {
+  /// Specify source file
+  pub fn from_source(source: &'a path::Path) -> Move<'a> {
+    Self { source, temp: None }
+  }
+
+  /// If specified and the destination file already exists, the "destination"
+  /// file will be moved to the given temporary location before the "source"
+  /// file is moved to the "destination" file.
+  ///
+  /// In the event of an `io` error while renaming "source" to "destination",
+  /// the temporary file will be moved back to "destination".
+  ///
+  /// The `temp` dir must be explicitly provided since `rename` operations require
+  /// files to live on the same filesystem.
+  pub fn replace_using_temp(&mut self, temp: &'a path::Path) -> &mut Self {
+    self.temp = Some(temp);
+    self
+  }
+
+  /// Move source file to specified destination
+  pub fn to_dest(&self, dest: &path::Path) -> Result<(), Error> {
+    match self.temp {
+      None => {
+        fs::rename(self.source, dest)?;
+      }
+      Some(temp) => {
+        println!("dest {}", dest.to_str().unwrap());
+        println!("temp {}", temp.to_str().unwrap());
+        println!("source {}", self.source.to_str().unwrap());
+        if dest.exists() {
+          fs::rename(dest, temp)?;
+          if let Err(e) = fs::rename(self.source, dest) {
+            fs::rename(temp, dest)?;
+            return Err(Error::from(e));
+          }
+        } else {
+          fs::rename(self.source, dest)?;
+        }
+      }
+    };
+    Ok(())
+  }
+}

lib/rust/src/file/mod.rs

@@ -0,0 +1,21 @@
+use std::fs;
+
+extern crate serde_json;
+
+mod error;
+mod extract;
+mod file_move;
+
+pub use error::Error;
+pub use extract::*;
+pub use file_move::*;
+
+pub fn read_string(file: String) -> Result<String, String> {
+  fs::read_to_string(file)
+    .map_err(|err| err.to_string())
+    .map(|c| c)
+}
+
+pub fn read_binary(file: String) -> Result<Vec<u8>, String> {
+  fs::read(file).map_err(|err| err.to_string()).map(|b| b)
+}

lib/rust/src/file_system.rs

@@ -0,0 +1,100 @@
+use proton_ui::WebView;
+
+use super::dir;
+use super::file;
+use super::run_async;
+
+use std::fs::File;
+use std::io::Write;
+
+pub fn list<T: 'static>(webview: &mut WebView<T>, path: String, callback: String, error: String) {
+  run_async(
+    webview,
+    move || {
+      dir::walk_dir(path.to_string())
+        .and_then(|f| serde_json::to_string(&f).map_err(|err| err.to_string()))
+    },
+    callback,
+    error,
+  );
+}
+
+pub fn list_dirs<T: 'static>(
+  webview: &mut WebView<T>,
+  path: String,
+  callback: String,
+  error: String,
+) {
+  run_async(
+    webview,
+    move || {
+      dir::list_dir_contents(&path)
+        .and_then(|f| serde_json::to_string(&f).map_err(|err| err.to_string()))
+    },
+    callback,
+    error,
+  );
+}
+
+pub fn write_file<T: 'static>(
+  webview: &mut WebView<T>,
+  file: String,
+  contents: String,
+  callback: String,
+  error: String,
+) {
+  run_async(
+    webview,
+    move || {
+      File::create(file)
+        .map_err(|err| err.to_string())
+        .and_then(|mut f| {
+          f.write_all(contents.as_bytes())
+            .map_err(|err| err.to_string())
+            .map(|_| "".to_string())
+        })
+    },
+    callback,
+    error,
+  );
+}
+
+pub fn read_text_file<T: 'static>(
+  webview: &mut WebView<T>,
+  path: String,
+  callback: String,
+  error: String,
+) {
+  run_async(
+    webview,
+    move || {
+      file::read_string(path).and_then(|f| {
+        serde_json::to_string(&f)
+          .map_err(|err| err.to_string())
+          .map(|s| s.to_string())
+      })
+    },
+    callback,
+    error,
+  );
+}
+
+pub fn read_binary_file<T: 'static>(
+  webview: &mut WebView<T>,
+  path: String,
+  callback: String,
+  error: String,
+) {
+  run_async(
+    webview,
+    move || {
+      file::read_binary(path).and_then(|f| {
+        serde_json::to_string(&f)
+          .map_err(|err| err.to_string())
+          .map(|s| s.to_string())
+      })
+    },
+    callback,
+    error,
+  );
+}

lib/rust/src/http/error.rs

@@ -0,0 +1,57 @@
+use reqwest;
+use serde_json;
+use std;
+
+#[derive(Debug)]
+pub enum Error {
+  Download(String),
+  Json(serde_json::Error),
+  Reqwest(reqwest::Error),
+  Io(std::io::Error),
+}
+
+impl std::fmt::Display for Error {
+  fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    use Error::*;
+    match *self {
+      Download(ref s) => write!(f, "DownloadError: {}", s),
+      Json(ref e) => write!(f, "JsonError: {}", e),
+      Reqwest(ref e) => write!(f, "ReqwestError: {}", e),
+      Io(ref e) => write!(f, "IoError: {}", e),
+    }
+  }
+}
+
+impl std::error::Error for Error {
+  fn description(&self) -> &str {
+    "Http Error"
+  }
+
+  fn cause(&self) -> Option<&std::error::Error> {
+    use Error::*;
+    Some(match *self {
+      Json(ref e) => e,
+      Reqwest(ref e) => e,
+      Io(ref e) => e,
+      _ => return None,
+    })
+  }
+}
+
+impl From<serde_json::Error> for Error {
+  fn from(e: serde_json::Error) -> Self {
+    Error::Json(e)
+  }
+}
+
+impl From<reqwest::Error> for Error {
+  fn from(e: reqwest::Error) -> Self {
+    Error::Reqwest(e)
+  }
+}
+
+impl From<std::io::Error> for Error {
+  fn from(e: std::io::Error) -> Self {
+    Error::Io(e)
+  }
+}

lib/rust/src/http/mod.rs

@@ -0,0 +1,80 @@
+extern crate pbr;
+extern crate reqwest;
+
+use serde::Serialize;
+use std::io;
+mod error;
+pub use self::error::Error;
+
+pub fn get(url: &String) -> Result<reqwest::Response, Error> {
+  let response = reqwest::Client::new().get(url).send()?;
+  Ok(response)
+}
+
+pub fn post_as_json<T: Serialize + ?Sized>(
+  url: &String,
+  payload: &T,
+) -> Result<reqwest::Response, Error> {
+  let response = reqwest::Client::new().post(url).json(payload).send()?;
+  Ok(response)
+}
+
+pub fn download<T: io::Write>(
+  url: &String,
+  mut dest: T,
+  display_progress: bool,
+) -> Result<(), Error> {
+  use io::BufRead;
+
+  set_ssl_vars!();
+
+  let resp = get(url)?;
+  let size = resp
+    .headers()
+    .get(reqwest::header::CONTENT_LENGTH)
+    .map(|val| {
+      val
+        .to_str()
+        .map(|s| s.parse::<u64>().unwrap_or(0))
+        .unwrap_or(0)
+    })
+    .unwrap_or(0);
+
+  if !resp.status().is_success() {
+    bail!(
+      Error::Download,
+      "Download request failed with status: {:?}",
+      resp.status()
+    )
+  }
+
+  let show_progress = if size == 0 { false } else { display_progress };
+
+  let mut src = io::BufReader::new(resp);
+  let mut bar = if show_progress {
+    let mut bar = pbr::ProgressBar::new(size);
+    bar.set_units(pbr::Units::Bytes);
+    bar.format("[=> ]");
+    Some(bar)
+  } else {
+    None
+  };
+  loop {
+    let n = {
+      let buf = src.fill_buf()?;
+      dest.write_all(&buf)?;
+      buf.len()
+    };
+    if n == 0 {
+      break;
+    }
+    src.consume(n);
+    if let Some(ref mut bar) = bar {
+      bar.add(n as u64);
+    }
+  }
+  if show_progress {
+    println!(" ... Done");
+  }
+  Ok(())
+}

lib/rust/src/lib.rs

@@ -0,0 +1,43 @@
+extern crate threadpool;
+#[macro_use]
+extern crate serde_derive;
+
+#[macro_use]
+mod macros;
+
+pub mod api;
+pub mod command;
+pub mod dir;
+pub mod file;
+pub mod file_system;
+pub mod http;
+pub mod platform;
+pub mod process;
+pub mod rpc;
+pub mod tcp;
+pub mod updater;
+pub mod version;
+
+extern crate proton_ui;
+use proton_ui::WebView;
+
+use threadpool::ThreadPool;
+
+thread_local!(static POOL: ThreadPool = ThreadPool::new(4));
+
+pub fn run_async<T: 'static, F: FnOnce() -> Result<String, String> + Send + 'static>(
+  webview: &mut WebView<T>,
+  what: F,
+  callback: String,
+  error: String,
+) {
+  let handle = webview.handle();
+  POOL.with(|thread| {
+    thread.execute(move || {
+      let callback_string = rpc::format_callback_result(what(), callback, error);
+      handle
+        .dispatch(move |_webview| _webview.eval(callback_string.as_str()))
+        .unwrap()
+    });
+  });
+}

lib/rust/src/macros.rs

@@ -0,0 +1,46 @@
+/// Helper for formatting `errors::Error`s
+macro_rules! format_err {
+    ($e_type:expr, $literal:expr) => {
+        $e_type(format!($literal))
+    };
+    ($e_type:expr, $literal:expr, $($arg:expr),*) => {
+        $e_type(format!($literal, $($arg),*))
+    };
+}
+
+/// Helper for formatting `errors::Error`s and returning early
+macro_rules! bail {
+    ($e_type:expr, $literal:expr) => {
+        return Err(format_err!($e_type, $literal))
+    };
+    ($e_type:expr, $literal:expr, $($arg:expr),*) => {
+        return Err(format_err!($e_type, $literal, $($arg),*))
+    };
+}
+
+/// Helper to `print!` and immediately `flush` `stdout`
+macro_rules! print_flush {
+    ($literal:expr) => {
+        print!($literal);
+        ::std::io::Write::flush(&mut ::std::io::stdout())?;
+    };
+    ($literal:expr, $($arg:expr),*) => {
+        print!($literal, $($arg),*);
+        ::std::io::Write::flush(&mut ::std::io::stdout())?;
+    }
+}
+
+/// Set ssl cert env. vars to make sure openssl can find required files
+macro_rules! set_ssl_vars {
+  () => {
+    #[cfg(target_os = "linux")]
+    {
+      if ::std::env::var_os("SSL_CERT_FILE").is_none() {
+        ::std::env::set_var("SSL_CERT_FILE", "/etc/ssl/certs/ca-certificates.crt");
+      }
+      if ::std::env::var_os("SSL_CERT_DIR").is_none() {
+        ::std::env::set_var("SSL_CERT_DIR", "/etc/ssl/certs");
+      }
+    }
+  };
+}

lib/rust/src/platform/error.rs

@@ -0,0 +1,29 @@
+use std;
+
+#[derive(Debug)]
+pub enum Error {
+  Arch(String),
+  Target(String),
+  Abi(String),
+}
+
+impl std::fmt::Display for Error {
+  fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    use Error::*;
+    match *self {
+      Arch(ref s) => write!(f, "ArchError: {}", s),
+      Target(ref e) => write!(f, "TargetError: {}", e),
+      Abi(ref e) => write!(f, "AbiError: {}", e),
+    }
+  }
+}
+
+impl std::error::Error for Error {
+  fn description(&self) -> &str {
+    "Platform Error"
+  }
+
+  fn cause(&self) -> Option<&std::error::Error> {
+    return None;
+  }
+}

lib/rust/src/platform/mod.rs

@@ -0,0 +1,54 @@
+pub mod error;
+use error::*;
+
+/// Try to determine the current target triple.
+///
+/// Returns a target triple (e.g. `x86_64-unknown-linux-gnu` or `i686-pc-windows-msvc`) or an
+/// `Error::Config` if the current config cannot be determined or is not some combination of the
+/// following values:
+/// `linux, mac, windows` -- `i686, x86, armv7` -- `gnu, musl, msvc`
+///
+/// * Errors:
+///     * Unexpected system config
+pub fn target_triple() -> Result<String, Error> {
+  let arch = if cfg!(target_arch = "x86") {
+    "i686"
+  } else if cfg!(target_arch = "x86_64") {
+    "x86_64"
+  } else if cfg!(target_arch = "arm") {
+    "armv7"
+  } else {
+    bail!(Error::Arch, "Unable to determine target-architecture")
+  };
+
+  let os = if cfg!(target_os = "linux") {
+    "unknown-linux"
+  } else if cfg!(target_os = "macos") {
+    "apple-darwin"
+  } else if cfg!(target_os = "windows") {
+    "pc-windows"
+  } else if cfg!(target_os = "freebsd") {
+    "unknown-freebsd"
+  } else {
+    bail!(Error::Target, "Unable to determine target-os");
+  };
+
+  let s;
+  let os = if cfg!(target_os = "macos") || cfg!(target_os = "freebsd") {
+    os
+  } else {
+    let env = if cfg!(target_env = "gnu") {
+      "gnu"
+    } else if cfg!(target_env = "gnu") {
+      "musl"
+    } else if cfg!(target_env = "msvc") {
+      "msvc"
+    } else {
+      bail!(Error::Abi, "Unable to determine target-environment")
+    };
+    s = format!("{}-{}", os, env);
+    &s
+  };
+
+  Ok(format!("{}-{}", arch, os))
+}

lib/rust/src/process.rs

@@ -0,0 +1,18 @@
+extern crate sysinfo;
+
+pub use sysinfo::{Process, ProcessExt, Signal, System, SystemExt};
+
+pub fn get_parent_process(system: &mut sysinfo::System) -> Result<&Process, String> {
+  let pid = sysinfo::get_current_pid().unwrap();
+  system.refresh_process(pid);
+  let current_process = system
+    .get_process(pid)
+    .ok_or("Could not get current process")?;
+  let parent_pid = current_process.parent().ok_or("Could not get parent PID")?;
+  let parent_process = system
+    .get_process(parent_pid)
+    .ok_or("Could not get parent process")?;
+
+  println!("{}", pid);
+  Ok(parent_process)
+}

lib/rust/src/rpc.rs

@@ -0,0 +1,15 @@
+pub fn format_callback(function_name: String, arg: String) -> String {
+  let formatted_string = &format!("window[\"{}\"]({})", function_name, arg);
+  return formatted_string.to_string();
+}
+
+pub fn format_callback_result(
+  result: Result<String, String>,
+  callback: String,
+  error_callback: String,
+) -> String {
+  match result {
+    Ok(res) => return format_callback(callback, res),
+    Err(err) => return format_callback(error_callback, format!("\"{}\"", err)),
+  }
+}

lib/rust/src/tcp.rs

@@ -0,0 +1,25 @@
+use std::net::TcpListener;
+
+extern crate rand;
+
+use rand::distributions::{Distribution, Uniform};
+
+pub fn get_available_port() -> Option<u16> {
+  let mut rng = rand::thread_rng();
+  let die = Uniform::from(8000..9000);
+
+  for _i in 0..100 {
+    let port = die.sample(&mut rng);
+    if port_is_available(port) {
+      return Some(port);
+    }
+  }
+  None
+}
+
+pub fn port_is_available(port: u16) -> bool {
+  match TcpListener::bind(("127.0.0.1", port)) {
+    Ok(_) => true,
+    Err(_) => false,
+  }
+}

lib/rust/src/updater/error.rs

@@ -0,0 +1,78 @@
+use super::super::file;
+use super::super::http;
+use super::super::version;
+use reqwest;
+use std;
+use zip::result::ZipError;
+
+#[derive(Debug)]
+pub enum Error {
+  Updater(String),
+  Release(String),
+  Network(String),
+  Config(String),
+  Io(std::io::Error),
+  Zip(ZipError),
+  File(file::Error),
+  Version(version::Error),
+}
+
+impl std::fmt::Display for Error {
+  fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    use Error::*;
+    match *self {
+      Updater(ref s) => write!(f, "UpdaterError: {}", s),
+      Release(ref s) => write!(f, "ReleaseError: {}", s),
+      Network(ref s) => write!(f, "NetworkError: {}", s),
+      Config(ref s) => write!(f, "ConfigError: {}", s),
+      Io(ref e) => write!(f, "IoError: {}", e),
+      Zip(ref e) => write!(f, "ZipError: {}", e),
+      File(ref e) => write!(f, "FileError: {}", e),
+      Version(ref e) => write!(f, "VersionError: {}", e),
+    }
+  }
+}
+
+impl std::error::Error for Error {
+  fn description(&self) -> &str {
+    "Updater Error"
+  }
+
+  fn cause(&self) -> Option<&std::error::Error> {
+    use Error::*;
+    Some(match *self {
+      Io(ref e) => e,
+      _ => return None,
+    })
+  }
+}
+
+impl From<std::io::Error> for Error {
+  fn from(e: std::io::Error) -> Self {
+    Error::Io(e)
+  }
+}
+
+impl From<file::Error> for Error {
+  fn from(e: file::Error) -> Self {
+    Error::File(e)
+  }
+}
+
+impl From<http::Error> for Error {
+  fn from(e: http::Error) -> Self {
+    Error::Network(e.to_string())
+  }
+}
+
+impl From<reqwest::Error> for Error {
+  fn from(e: reqwest::Error) -> Self {
+    Error::Network(e.to_string())
+  }
+}
+
+impl From<version::Error> for Error {
+  fn from(e: version::Error) -> Self {
+    Error::Version(e)
+  }
+}

lib/rust/src/updater/github/mod.rs

@@ -0,0 +1,43 @@
+mod release;
+pub use super::error::Error;
+pub use release::*;
+
+use super::super::http;
+
+pub fn get_latest_release(repo_owner: &str, repo_name: &str) -> Result<Release, Error> {
+  set_ssl_vars!();
+  let api_url = format!(
+    "https://api.github.com/repos/{}/{}/releases/latest",
+    repo_owner, repo_name
+  );
+  let mut resp = http::get(&api_url)?;
+  if !resp.status().is_success() {
+    bail!(
+      Error::Network,
+      "api request failed with status: {:?} - for: {:?}",
+      resp.status(),
+      api_url
+    )
+  }
+  let json = resp.json::<serde_json::Value>()?;
+  Ok(Release::parse(&json)?)
+}
+
+pub fn get_release_version(repo_owner: &str, repo_name: &str, ver: &str) -> Result<Release, Error> {
+  set_ssl_vars!();
+  let api_url = format!(
+    "https://api.github.com/repos/{}/{}/releases/tags/{}",
+    repo_owner, repo_name, ver
+  );
+  let mut resp = http::get(&api_url)?;
+  if !resp.status().is_success() {
+    bail!(
+      Error::Network,
+      "api request failed with status: {:?} - for: {:?}",
+      resp.status(),
+      api_url
+    )
+  }
+  let json = resp.json::<serde_json::Value>()?;
+  Ok(Release::parse(&json)?)
+}

lib/rust/src/updater/github/release.rs

@@ -0,0 +1,215 @@
+use super::super::error::*;
+use hyper_old_types::header::{LinkValue, RelationType};
+use serde_json;
+
+/// GitHub release-asset information
+#[derive(Clone, Debug)]
+pub struct ReleaseAsset {
+  pub download_url: String,
+  pub name: String,
+}
+impl ReleaseAsset {
+  /// Parse a release-asset json object
+  ///
+  /// Errors:
+  ///     * Missing required name & browser_download_url keys
+  fn from_asset(asset: &serde_json::Value) -> Result<ReleaseAsset, Error> {
+    let download_url = asset["browser_download_url"]
+      .as_str()
+      .ok_or_else(|| format_err!(Error::Release, "Asset missing `browser_download_url`"))?;
+    let name = asset["name"]
+      .as_str()
+      .ok_or_else(|| format_err!(Error::Release, "Asset missing `name`"))?;
+    Ok(ReleaseAsset {
+      download_url: download_url.to_owned(),
+      name: name.to_owned(),
+    })
+  }
+}
+
+#[derive(Clone, Debug)]
+pub struct Release {
+  pub name: String,
+  pub body: String,
+  pub tag: String,
+  pub date_created: String,
+  pub assets: Vec<ReleaseAsset>,
+}
+impl Release {
+  pub fn parse(release: &serde_json::Value) -> Result<Release, Error> {
+    let tag = release["tag_name"]
+      .as_str()
+      .ok_or_else(|| format_err!(Error::Release, "Release missing `tag_name`"))?;
+    let date_created = release["created_at"]
+      .as_str()
+      .ok_or_else(|| format_err!(Error::Release, "Release missing `created_at`"))?;
+    let name = release["name"].as_str().unwrap_or(tag);
+    let body = release["body"].as_str().unwrap_or("");
+    let assets = release["assets"]
+      .as_array()
+      .ok_or_else(|| format_err!(Error::Release, "No assets found"))?;
+    let assets = assets
+      .iter()
+      .map(ReleaseAsset::from_asset)
+      .collect::<Result<Vec<ReleaseAsset>, Error>>()?;
+    Ok(Release {
+      name: name.to_owned(),
+      body: body.to_owned(),
+      tag: tag.to_owned(),
+      date_created: date_created.to_owned(),
+      assets,
+    })
+  }
+
+  /// Check if release has an asset who's name contains the specified `target`
+  pub fn has_target_asset(&self, target: &str) -> bool {
+    self.assets.iter().any(|asset| asset.name.contains(target))
+  }
+
+  /// Return the first `ReleaseAsset` for the current release who's name
+  /// contains the specified `target`
+  pub fn asset_for(&self, target: &str) -> Option<ReleaseAsset> {
+    self
+      .assets
+      .iter()
+      .filter(|asset| asset.name.contains(target))
+      .cloned()
+      .nth(0)
+  }
+
+  pub fn version(&self) -> &str {
+    self.tag.trim_start_matches('v')
+  }
+}
+
+/// `ReleaseList` Builder
+#[derive(Clone, Debug)]
+pub struct ReleaseListBuilder {
+  repo_owner: Option<String>,
+  repo_name: Option<String>,
+  target: Option<String>,
+}
+impl ReleaseListBuilder {
+  /// Set the repo owner, used to build a github api url
+  pub fn repo_owner(&mut self, owner: &str) -> &mut Self {
+    self.repo_owner = Some(owner.to_owned());
+    self
+  }
+
+  /// Set the repo name, used to build a github api url
+  pub fn repo_name(&mut self, name: &str) -> &mut Self {
+    self.repo_name = Some(name.to_owned());
+    self
+  }
+
+  /// Set the optional arch `target` name, used to filter available releases
+  pub fn target(&mut self, target: &str) -> &mut Self {
+    self.target = Some(target.to_owned());
+    self
+  }
+
+  /// Verify builder args, returning a `ReleaseList`
+  pub fn build(&self) -> Result<ReleaseList, Error> {
+    Ok(ReleaseList {
+      repo_owner: if let Some(ref owner) = self.repo_owner {
+        owner.to_owned()
+      } else {
+        bail!(Error::Config, "`repo_owner` required")
+      },
+      repo_name: if let Some(ref name) = self.repo_name {
+        name.to_owned()
+      } else {
+        bail!(Error::Config, "`repo_name` required")
+      },
+      target: self.target.clone(),
+    })
+  }
+}
+
+/// `ReleaseList` provides a builder api for querying a GitHub repo,
+/// returning a `Vec` of available `Release`s
+#[derive(Clone, Debug)]
+pub struct ReleaseList {
+  repo_owner: String,
+  repo_name: String,
+  target: Option<String>,
+}
+impl ReleaseList {
+  /// Initialize a ReleaseListBuilder
+  pub fn configure() -> ReleaseListBuilder {
+    ReleaseListBuilder {
+      repo_owner: None,
+      repo_name: None,
+      target: None,
+    }
+  }
+
+  /// Retrieve a list of `Release`s.
+  /// If specified, filter for those containing a specified `target`
+  pub fn fetch(self) -> Result<Vec<Release>, Error> {
+    set_ssl_vars!();
+    let api_url = format!(
+      "https://api.github.com/repos/{}/{}/releases",
+      self.repo_owner, self.repo_name
+    );
+    let releases = Self::fetch_releases(&api_url)?;
+    let releases = match self.target {
+      None => releases,
+      Some(ref target) => releases
+        .into_iter()
+        .filter(|r| r.has_target_asset(target))
+        .collect::<Vec<_>>(),
+    };
+    Ok(releases)
+  }
+
+  fn fetch_releases(url: &str) -> Result<Vec<Release>, Error> {
+    let mut resp = reqwest::get(url)?;
+    if !resp.status().is_success() {
+      bail!(
+        Error::Network,
+        "api request failed with status: {:?} - for: {:?}",
+        resp.status(),
+        url
+      )
+    }
+    let releases = resp.json::<serde_json::Value>()?;
+    let releases = releases
+      .as_array()
+      .ok_or_else(|| format_err!(Error::Release, "No releases found"))?;
+    let mut releases = releases
+      .iter()
+      .map(Release::parse)
+      .collect::<Result<Vec<Release>, Error>>()?;
+
+    // handle paged responses containing `Link` header:
+    // `Link: <https://api.github.com/resource?page=2>; rel="next"`
+    let headers = resp.headers();
+    let links = headers.get_all(reqwest::header::LINK);
+
+    let next_link = links
+      .iter()
+      .filter_map(|link| {
+        if let Ok(link) = link.to_str() {
+          let lv = LinkValue::new(link.to_owned());
+          if let Some(rels) = lv.rel() {
+            if rels.contains(&RelationType::Next) {
+              return Some(link);
+            }
+          }
+          None
+        } else {
+          None
+        }
+      })
+      .nth(0);
+
+    Ok(match next_link {
+      None => releases,
+      Some(link) => {
+        releases.extend(Self::fetch_releases(link)?);
+        releases
+      }
+    })
+  }
+}

lib/rust/src/updater/mod.rs

@@ -0,0 +1,270 @@
+extern crate hyper_old_types;
+
+use std::env;
+use std::fs;
+use std::path::PathBuf;
+
+use super::file::{Extract, Move};
+use super::http;
+
+pub mod github;
+
+mod error;
+pub use error::Error;
+
+/// Status returned after updating
+///
+/// Wrapped `String`s are version tags
+#[derive(Debug, Clone)]
+pub enum Status {
+  UpToDate(String),
+  Updated(String),
+}
+impl Status {
+  /// Return the version tag
+  pub fn version(&self) -> &str {
+    use Status::*;
+    match *self {
+      UpToDate(ref s) => s,
+      Updated(ref s) => s,
+    }
+  }
+
+  /// Returns `true` if `Status::UpToDate`
+  pub fn uptodate(&self) -> bool {
+    match *self {
+      Status::UpToDate(_) => true,
+      _ => false,
+    }
+  }
+
+  /// Returns `true` if `Status::Updated`
+  pub fn updated(&self) -> bool {
+    match *self {
+      Status::Updated(_) => true,
+      _ => false,
+    }
+  }
+}
+
+#[derive(Clone, Debug)]
+pub struct Release {
+  pub version: String,
+  pub asset_name: String,
+  pub download_url: String,
+}
+
+#[derive(Debug)]
+pub struct UpdateBuilder {
+  release: Option<Release>,
+  bin_name: Option<String>,
+  bin_install_path: Option<PathBuf>,
+  bin_path_in_archive: Option<PathBuf>,
+  show_download_progress: bool,
+  show_output: bool,
+  current_version: Option<String>,
+}
+impl UpdateBuilder {
+  /// Initialize a new builder, defaulting the `bin_install_path` to the current
+  /// executable's path
+  ///
+  /// * Errors:
+  ///     * Io - Determining current exe path
+  pub fn new() -> Result<Self, Error> {
+    Ok(Self {
+      release: None,
+      bin_name: None,
+      bin_install_path: Some(env::current_exe()?),
+      bin_path_in_archive: None,
+      show_download_progress: false,
+      show_output: true,
+      current_version: None,
+    })
+  }
+
+  pub fn release(&mut self, release: Release) -> &mut Self {
+    self.release = Some(release);
+    self
+  }
+
+  /// Set the current app version, used to compare against the latest available version.
+  /// The `cargo_crate_version!` macro can be used to pull the version from your `Cargo.toml`
+  pub fn current_version(&mut self, ver: &str) -> &mut Self {
+    self.current_version = Some(ver.to_owned());
+    self
+  }
+
+  /// Set the exe's name. Also sets `bin_path_in_archive` if it hasn't already been set.
+  pub fn bin_name(&mut self, name: &str) -> &mut Self {
+    self.bin_name = Some(name.to_owned());
+    if self.bin_path_in_archive.is_none() {
+      self.bin_path_in_archive = Some(PathBuf::from(name));
+    }
+    self
+  }
+
+  /// Set the installation path for the new exe, defaults to the current
+  /// executable's path
+  pub fn bin_install_path(&mut self, bin_install_path: &str) -> &mut Self {
+    self.bin_install_path = Some(PathBuf::from(bin_install_path));
+    self
+  }
+
+  /// Set the path of the exe inside the release tarball. This is the location
+  /// of the executable relative to the base of the tar'd directory and is the
+  /// path that will be copied to the `bin_install_path`. If not specified, this
+  /// will default to the value of `bin_name`. This only needs to be specified if
+  /// the path to the binary (from the root of the tarball) is not equal to just
+  /// the `bin_name`.
+  ///
+  /// # Example
+  ///
+  /// For a tarball `myapp.tar.gz` with the contents:
+  ///
+  /// ```shell
+  /// myapp.tar/
+  ///  |------- bin/
+  ///  |         |--- myapp  # <-- executable
+  /// ```
+  ///
+  /// The path provided should be:
+  ///
+  /// ```
+  /// # use proton::updater::Update;
+  /// # fn run() -> Result<(), Box<::std::error::Error>> {
+  /// Update::configure()?
+  ///     .bin_path_in_archive("bin/myapp")
+  /// #   .build()?;
+  /// # Ok(())
+  /// # }
+  /// ```
+  pub fn bin_path_in_archive(&mut self, bin_path: &str) -> &mut Self {
+    self.bin_path_in_archive = Some(PathBuf::from(bin_path));
+    self
+  }
+
+  /// Toggle download progress bar, defaults to `off`.
+  pub fn show_download_progress(&mut self, show: bool) -> &mut Self {
+    self.show_download_progress = show;
+    self
+  }
+
+  /// Toggle update output information, defaults to `true`.
+  pub fn show_output(&mut self, show: bool) -> &mut Self {
+    self.show_output = show;
+    self
+  }
+
+  /// Confirm config and create a ready-to-use `Update`
+  ///
+  /// * Errors:
+  ///     * Config - Invalid `Update` configuration
+  pub fn build(&self) -> Result<Update, Error> {
+    Ok(Update {
+      release: if let Some(ref release) = self.release {
+        release.to_owned()
+      } else {
+        bail!(Error::Config, "`release` required")
+      },
+      bin_name: if let Some(ref name) = self.bin_name {
+        name.to_owned()
+      } else {
+        bail!(Error::Config, "`bin_name` required")
+      },
+      bin_install_path: if let Some(ref path) = self.bin_install_path {
+        path.to_owned()
+      } else {
+        bail!(Error::Config, "`bin_install_path` required")
+      },
+      bin_path_in_archive: if let Some(ref path) = self.bin_path_in_archive {
+        path.to_owned()
+      } else {
+        bail!(Error::Config, "`bin_path_in_archive` required")
+      },
+      current_version: if let Some(ref ver) = self.current_version {
+        ver.to_owned()
+      } else {
+        bail!(Error::Config, "`current_version` required")
+      },
+      show_download_progress: self.show_download_progress,
+      show_output: self.show_output,
+    })
+  }
+}
+
+/// Updates to a specified or latest release distributed
+#[derive(Debug)]
+pub struct Update {
+  release: Release,
+  current_version: String,
+  bin_name: String,
+  bin_install_path: PathBuf,
+  bin_path_in_archive: PathBuf,
+  show_download_progress: bool,
+  show_output: bool,
+}
+impl Update {
+  /// Initialize a new `Update` builder
+  pub fn configure() -> Result<UpdateBuilder, Error> {
+    UpdateBuilder::new()
+  }
+
+  fn print_flush(&self, msg: &str) -> Result<(), Error> {
+    if self.show_output {
+      print_flush!("{}", msg);
+    }
+    Ok(())
+  }
+
+  fn println(&self, msg: &str) {
+    if self.show_output {
+      println!("{}", msg);
+    }
+  }
+
+  pub fn update(self) -> Result<Status, Error> {
+    self.println(&format!(
+      "Checking current version... v{}",
+      self.current_version
+    ));
+
+    if self.show_output {
+      println!("\n{} release status:", self.bin_name);
+      println!("  * Current exe: {:?}", self.bin_install_path);
+      println!("  * New exe download url: {:?}", self.release.download_url);
+      println!(
+        "\nThe new release will be downloaded/extracted and the existing binary will be replaced."
+      );
+    }
+
+    let tmp_dir_parent = self
+      .bin_install_path
+      .parent()
+      .ok_or_else(|| Error::Updater("Failed to determine parent dir".into()))?;
+    let tmp_dir =
+      tempdir::TempDir::new_in(&tmp_dir_parent, &format!("{}_download", self.bin_name))?;
+    let tmp_archive_path = tmp_dir.path().join(&self.release.asset_name);
+    let mut tmp_archive = fs::File::create(&tmp_archive_path)?;
+
+    self.println("Downloading...");
+    http::download(
+      &self.release.download_url,
+      &mut tmp_archive,
+      self.show_download_progress,
+    )?;
+
+    self.print_flush("Extracting archive... ")?;
+    Extract::from_source(&tmp_archive_path)
+      .extract_file(&tmp_dir.path(), &self.bin_path_in_archive)?;
+    let new_exe = tmp_dir.path().join(&self.bin_path_in_archive);
+    self.println("Done");
+
+    self.print_flush("Replacing binary file... ")?;
+    let tmp_file = tmp_dir.path().join(&format!("__{}_backup", self.bin_name));
+    Move::from_source(&new_exe)
+      .replace_using_temp(&tmp_file)
+      .to_dest(&self.bin_install_path)?;
+    self.println("Done");
+    Ok(Status::Updated(self.release.version))
+  }
+}

lib/rust/src/version/error.rs

@@ -0,0 +1,35 @@
+use semver;
+use std;
+
+#[derive(Debug)]
+pub enum Error {
+  SemVer(semver::SemVerError),
+}
+
+impl std::fmt::Display for Error {
+  fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    use Error::*;
+    match *self {
+      SemVer(ref e) => write!(f, "SemVerError: {}", e),
+    }
+  }
+}
+
+impl std::error::Error for Error {
+  fn description(&self) -> &str {
+    "Version Error"
+  }
+
+  fn cause(&self) -> Option<&std::error::Error> {
+    use Error::*;
+    Some(match *self {
+      SemVer(ref e) => e,
+    })
+  }
+}
+
+impl From<semver::SemVerError> for Error {
+  fn from(e: semver::SemVerError) -> Self {
+    Error::SemVer(e)
+  }
+}

lib/rust/src/version/mod.rs

@@ -0,0 +1,53 @@
+use semver::Version;
+
+mod error;
+pub use self::error::Error;
+
+/// Compare two semver versions
+pub fn compare(first: &str, second: &str) -> Result<i32, Error> {
+  let v1 = Version::parse(first)?;
+  let v2 = Version::parse(second)?;
+  if v1 > v2 {
+    Ok(-1)
+  } else if v1 == v2 {
+    Ok(0)
+  } else {
+    Ok(1)
+  }
+}
+
+/// Check if the "second" semver is compatible with the "first"
+pub fn is_compatible(first: &str, second: &str) -> Result<bool, Error> {
+  let first = Version::parse(first)?;
+  let second = Version::parse(second)?;
+  Ok(if second.major == 0 && first.major == 0 {
+    first.minor == second.minor && second.patch > first.patch
+  } else if second.major > 0 {
+    first.major == second.major
+      && ((second.minor > first.minor)
+        || (first.minor == second.minor && second.patch > first.patch))
+  } else {
+    false
+  })
+}
+
+/// Check if a the "other" version is a major bump from the "current"
+pub fn is_major(current: &str, other: &str) -> Result<bool, Error> {
+  let current = Version::parse(current)?;
+  let other = Version::parse(other)?;
+  Ok(other.major > current.major)
+}
+
+/// Check if a the "other" version is a minor bump from the "current"
+pub fn is_minor(current: &str, other: &str) -> Result<bool, Error> {
+  let current = Version::parse(current)?;
+  let other = Version::parse(other)?;
+  Ok(current.major == other.major && other.minor > current.minor)
+}
+
+/// Check if a the "other" version is a patch bump from the "current"
+pub fn is_patch(current: &str, other: &str) -> Result<bool, Error> {
+  let current = Version::parse(current)?;
+  let other = Version::parse(other)?;
+  Ok(current.major == other.major && current.minor == other.minor && other.patch > current.patch)
+}

package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@quasar/proton",
+  "version": "1.0.0-alpha.1",
+  "description": "Multi-binding collection of libraries and templates for building Proton",
+  "main": "templates/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/quasarframework/proton.git"
+  },
+  "author": "Quasar Framework",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/quasarframework/proton/issues"
+  },
+  "homepage": "https://github.com/quasarframework/proton#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">= 10.16.0",
+    "npm": ">= 6.6.0",
+    "yarn": ">= 1.17.3"
+  }
+}

spec/README.md

@@ -0,0 +1 @@
+[WIP]

templates/rust/Cargo.toml

@@ -0,0 +1,39 @@
+[package]
+name = "app"
+version = "0.1.0"
+description = "A Quasar app"
+authors = ["Lucas Fernandes Nogueira <lucasfernandesnog@gmail.com>"]
+edition = "2018"
+build = "build.rs"
+include = ["data"]
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+proton-ui = { path = "../../proton/bindings/rust" }
+serde_json = "1.0.39"
+serde = "1.0"
+serde_derive = "1.0"
+tiny_http = "0.6"
+clap = {version = "2.33", features = ["yaml"]}
+phf = "0.7.21"
+includedir = "0.5.0"
+proton = { path = "../../proton/lib/rust" }
+
+[build-dependencies]
+includedir_codegen = "0.5.0"
+
+[features]
+dev = [] # has no explicit dependencies
+
+[package.metadata.bundle]
+identifier = "com.quasar.dev"
+icon = ["icons/32x32.png", "icons/128x128.png", "icons/128x128@2x.png", "icons/icon.icns", "icons/icon.ico"]
+
+[[bin]]
+name = "updater"
+path = "src/updater.rs"
+
+[[bin]]
+name = "app"
+path = "src/main.rs"

templates/rust/_gitignore

@@ -0,0 +1,10 @@
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+
+# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
+# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
+Cargo.lock
+
+# These are backup files generated by rustfmt
+**/*.rs.bk

templates/rust/build.rs

@@ -0,0 +1,10 @@
+extern crate includedir_codegen;
+
+use includedir_codegen::Compression;
+
+fn main() {
+  includedir_codegen::start("ASSETS")
+    .dir("./target/compiled-web", Compression::Gzip)
+    .build("data.rs")
+    .unwrap();
+}

templates/rust/rustfmt.toml

@@ -0,0 +1,13 @@
+max_width = 100
+hard_tabs = false
+tab_spaces = 2
+newline_style = "Auto"
+use_small_heuristics = "Default"
+reorder_imports = true
+reorder_modules = true
+remove_nested_parens = true
+edition = "2015"
+merge_derives = true
+use_try_shorthand = false
+use_field_init_shorthand = false
+force_explicit_abi = true

templates/rust/src/cmd.rs

@@ -0,0 +1,8 @@
+#[derive(Deserialize)]
+#[serde(tag = "cmd", rename_all = "camelCase")]
+pub enum Cmd {
+  // your custom commands
+  // multiple arguments are allowed
+  // note that rename_all = "camelCase": you need to use "myCustomCommand" on JS
+  MyCustomCommand { argument: String },
+}

templates/rust/src/main.rs

@@ -0,0 +1,112 @@
+#[macro_use]
+extern crate serde_derive;
+extern crate clap;
+extern crate proton;
+extern crate proton_ui;
+extern crate serde_json;
+
+#[cfg(not(feature = "dev"))]
+extern crate tiny_http;
+
+#[cfg(feature = "dev")]
+use clap::{App, Arg};
+
+#[cfg(not(feature = "dev"))]
+use std::thread;
+
+mod cmd;
+
+#[cfg(not(feature = "dev"))]
+mod server;
+
+fn main() {
+  let debug;
+  let content;
+  let _matches: clap::ArgMatches;
+
+  #[cfg(not(feature = "dev"))]
+  {
+    thread::spawn(|| {
+      proton::command::spawn_relative_command(
+        "updater".to_string(),
+        Vec::new(),
+        std::process::Stdio::inherit(),
+      )
+      .unwrap();
+    });
+  }
+
+  #[cfg(feature = "dev")]
+  {
+    let app = App::new("app")
+      .version("1.0.0")
+      .author("Author")
+      .about("About")
+      .arg(
+        Arg::with_name("url")
+          .short("u")
+          .long("url")
+          .value_name("URL")
+          .help("Loads the specified URL into webview")
+          .required(true)
+          .takes_value(true),
+      );
+
+    _matches = app.get_matches();
+    content = proton_ui::Content::Url(_matches.value_of("url").unwrap());
+    debug = true;
+  }
+  #[cfg(not(feature = "dev"))]
+  {
+    if let Some(available_port) = proton::tcp::get_available_port() {
+      let server_url = format!("{}:{}", "127.0.0.1", available_port);
+      content = proton_ui::Content::Url(format!("http://{}", server_url));
+      debug = cfg!(debug_assertions);
+
+      thread::spawn(move || {
+        let server = tiny_http::Server::http(server_url).unwrap();
+        for request in server.incoming_requests() {
+          let mut url = request.url().to_string();
+          if url == "/" {
+            url = "/index.html".to_string();
+          }
+          request.respond(server::asset_response(&url)).unwrap();
+        }
+      });
+    } else {
+      panic!("Could not find an open port");
+    }
+  }
+
+  let webview = proton_ui::builder()
+    .title("MyAppTitle")
+    .content(content)
+    .size(800, 600) // TODO:Resolution is fixed right now, change this later to be dynamic
+    .resizable(true)
+    .debug(debug)
+    .user_data(())
+    .invoke_handler(|_webview, arg| {
+      // leave this as is to use the proton API from your JS code
+      if !proton::api::handler(_webview, arg) {
+        use cmd::Cmd::*;
+        match serde_json::from_str(arg) {
+          Err(_) => {}
+          Ok(command) => {
+            match command {
+              // definitions for your custom commands from Cmd here
+              MyCustomCommand { argument } => {
+                //  your command code
+                println!("{}", argument);
+              }
+            }
+          }
+        }
+      }
+
+      Ok(())
+    })
+    .build()
+    .unwrap();
+
+  webview.run().unwrap();
+}

templates/rust/src/server.rs

@@ -0,0 +1,26 @@
+use tiny_http::{Header, Response};
+
+include!(concat!(env!("OUT_DIR"), "/data.rs"));
+
+pub fn asset_response(path: &str) -> Response<std::io::Cursor<Vec<u8>>> {
+  let asset = ASSETS
+    .get(&format!("./target/compiled-web{}", path))
+    .unwrap()
+    .into_owned();
+  let mut response = Response::from_data(asset);
+  let header;
+
+  if path.ends_with(".svg") {
+    header = Header::from_bytes(&b"Content-Type"[..], &b"image/svg+xml"[..]).unwrap();
+  } else if path.ends_with(".css") {
+    header = Header::from_bytes(&b"Content-Type"[..], &b"text/css"[..]).unwrap();
+  } else if path.ends_with(".html") {
+    header = Header::from_bytes(&b"Content-Type"[..], &b"text/html"[..]).unwrap();
+  } else {
+    header = Header::from_bytes(&b"Content-Type"[..], &b"appication/octet-stream"[..]).unwrap();
+  }
+
+  response.add_header(header);
+
+  response
+}

templates/rust/src/updater.rs

@@ -0,0 +1,73 @@
+extern crate proton;
+extern crate serde_derive;
+extern crate serde_json;
+
+use crate::proton::process::{ProcessExt, Signal, SystemExt};
+
+fn update() -> Result<(), String> {
+  let target = proton::platform::target_triple().map_err(|_| "Could not determine target")?;
+  let github_release = proton::updater::github::get_latest_release("jaemk", "self_update")
+    .map_err(|_| "Could not fetch latest release")?;
+  match github_release.asset_for(&target) {
+    Some(github_release_asset) => {
+      let release = proton::updater::Release {
+        version: github_release.tag.trim_start_matches('v').to_string(),
+        download_url: github_release_asset.download_url,
+        asset_name: github_release_asset.name,
+      };
+
+      let status = proton::updater::Update::configure()
+        .unwrap()
+        .release(release)
+        .bin_path_in_archive("github")
+        .bin_name("app")
+        .bin_install_path(&proton::command::command_path("app".to_string()).unwrap())
+        .show_download_progress(true)
+        .current_version(env!("CARGO_PKG_VERSION"))
+        .build()
+        .unwrap()
+        .update()
+        .unwrap();
+
+      println!("found release: {}", status.version());
+
+      /*let tmp_dir = proton::dir::with_temp_dir(|dir| {
+          let file_path = dir.path().join("my-temporary-note.pdf");
+          let mut tmp_archive = std::fs::File::create(file_path).unwrap();
+          proton::http::download(&"https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf".to_string(), &mut tmp_archive, true).unwrap();
+      });*/
+
+      Ok(())
+    }
+    None => Err(format!("Could not find release for target {}", target)),
+  }
+}
+
+fn restart_app(app_command: String) -> Result<(), String> {
+  let mut system = proton::process::System::new();
+  let parent_process = proton::process::get_parent_process(&mut system)
+    .map_err(|_| "Could not determine parent process")?;
+  if parent_process.name() == "app" {
+    parent_process.kill(Signal::Kill);
+    std::thread::sleep(std::time::Duration::from_secs(1));
+    std::process::Command::new(app_command)
+      .spawn()
+      .map_err(|_| "Could not start app")?;
+  }
+  Ok(())
+}
+
+fn run_updater() -> Result<(), String> {
+  let app_command = proton::command::relative_command("app".to_string())
+    .map_err(|_| "Could not determine app path")?;
+  update()?;
+  restart_app(app_command)?;
+  Ok(())
+}
+
+fn main() {
+  match run_updater() {
+    Ok(_) => {}
+    Err(err) => panic!(err),
+  };
+}

ui/.gitattributes

@@ -0,0 +1 @@
+*.h linguist-language=c

ui/.gitignore

@@ -0,0 +1,2 @@
+# Build atrifacts
+/build

ui/CMakeLists.txt

@@ -0,0 +1,32 @@
+cmake_minimum_required(VERSION 2.8)
+
+project(webview)
+
+if(APPLE)
+	set(WEBVIEW_COMPILE_DEFS "-DWEBVIEW_COCOA=1")
+	set(WEBVIEW_LIBS "-framework WebKit")
+elseif(WIN32)
+	set(WEBVIEW_COMPILE_DEFS "-DWEBVIEW_WINAPI=1")
+	set(WEBVIEW_LIBS "ole32 comctl32 oleaut32 uuid")
+else()
+	set(WEBVIEW_COMPILE_DEFS "-DWEBVIEW_GTK=1")
+	find_package(PkgConfig REQUIRED)
+	pkg_check_modules(GTK3 REQUIRED gtk+-3.0)
+	pkg_check_modules(WEBKIT2 REQUIRED webkit2gtk-4.0)
+	set(WEBVIEW_COMPILE_INCS ${GTK3_INCLUDE_DIRS} ${WEBKIT2_INCLUDE_DIRS} ${PROJECT_SOURCE_DIR})
+	set(WEBVIEW_LIBS ${GTK3_LIBRARIES} ${WEBKIT2_LIBRARIES})
+endif()
+
+add_library(proton ${CMAKE_CURRENT_BINARY_DIR}/proton.c)
+file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/proton.c "#define WEBVIEW_IMPLEMENTATION\n#include <proton.h>")
+target_include_directories(proton PUBLIC ${PROJECT_SOURCE_DIR} ${WEBVIEW_COMPILE_INCS})
+target_compile_definitions(proton PUBLIC ${WEBVIEW_COMPILE_DEFS})
+target_compile_options(proton PRIVATE ${WEBVIEW_COMPILE_OPTS})
+target_link_libraries(proton ${WEBVIEW_LIBS})
+
+add_executable(proton_test WIN32 MACOSX_BUNDLE proton_test.cc)
+set_target_properties(proton_test PROPERTIES CXX_STANDARD 11 CXX_STANDARD_REQUIRED YES CXX_EXTENSIONS NO)
+find_package(Threads)
+target_link_libraries(proton_test PRIVATE proton ${CMAKE_THREAD_LIBS_INIT})
+enable_testing ()
+add_test(NAME proton_test COMMAND proton_test)

ui/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 - present Serge Zaitsev & Quasar Framework Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ui/README.md

@@ -0,0 +1,3 @@
+# PROTON WEBVIEW
+
+Documentation forthcoming.

ui/proton_test.cc

@@ -0,0 +1,176 @@
+// +build ignore
+
+#include <cassert>
+#include <cstdio>
+#include <functional>
+#include <iostream>
+#include <string>
+#include <thread>
+#include <utility>
+#include <vector>
+
+#define WEBVIEW_IMPLEMENTATION
+#include "proton.h"
+
+extern "C" void webview_dispatch_proxy(struct webview *w, void *arg) {
+  (*static_cast<std::function<void(struct webview *)> *>(arg))(w);
+}
+
+class runner {
+public:
+  runner(struct webview *w) : w(w) { webview_init(this->w); }
+  ~runner() { webview_exit(this->w); }
+  runner &then(std::function<void(struct webview *w)> fn) {
+    auto arg = new std::pair<std::function<void(struct webview *)>, void *>(
+	fn, nullptr);
+    this->queue.push_back([=](struct webview *w) {
+      webview_dispatch(
+	  w,
+	  [](struct webview *w, void *arg) {
+	    auto dispatch_arg = reinterpret_cast<
+		std::pair<std::function<void(struct webview *)>, void *> *>(
+		arg);
+	    dispatch_arg->first(w);
+	    delete dispatch_arg;
+	  },
+	  reinterpret_cast<void *>(arg));
+    });
+    return *this;
+  }
+  runner &sleep(const int millis) {
+    this->queue.push_back([=](struct webview *w) {
+      (void)w;
+      std::this_thread::sleep_for(std::chrono::milliseconds(millis));
+    });
+    return *this;
+  }
+  void wait() {
+    this->then([](struct webview *w) { webview_terminate(w); });
+    auto q = this->queue;
+    auto w = this->w;
+    std::thread bg_thread([w, q]() {
+      for (auto f : q) {
+	f(w);
+      }
+    });
+    while (webview_loop(w, 1) == 0) {
+    }
+    bg_thread.join();
+  }
+
+private:
+  struct webview *w;
+  std::vector<std::function<void(struct webview *)>> queue;
+};
+
+static void test_minimal() {
+  struct webview w = {};
+  std::cout << "TEST: minimal" << std::endl;
+  w.title = "Minimal test";
+  w.width = 480;
+  w.height = 320;
+  webview_init(&w);
+  webview_dispatch(&w,
+		   [](struct webview *w, void *arg) {
+		     (void)arg;
+		     webview_terminate(w);
+		   },
+		   nullptr);
+  while (webview_loop(&w, 1) == 0) {
+  }
+  webview_exit(&w);
+}
+
+static void test_window_size() {
+  struct webview w = {};
+  std::vector<std::string> results;
+  std::cout << "TEST: window size" << std::endl;
+  w.width = 480;
+  w.height = 320;
+  w.resizable = 1;
+  w.userdata = static_cast<void *>(&results);
+  w.external_invoke_cb = [](struct webview *w, const char *arg) {
+    auto *v = static_cast<std::vector<std::string> *>(w->userdata);
+    v->push_back(std::string(arg));
+  };
+  runner(&w)
+      .then([](struct webview *w) {
+	webview_eval(w, "window.external.invoke(''+window.screen.width+' ' + "
+			"window.screen.height)");
+	webview_eval(w, "window.external.invoke(''+window.innerWidth+' ' + "
+			"window.innerHeight)");
+      })
+      .sleep(200)
+      .then([](struct webview *w) { webview_set_fullscreen(w, 1); })
+      .sleep(500)
+      .then([](struct webview *w) {
+	webview_eval(w, "window.external.invoke(''+window.innerWidth+' ' + "
+			"window.innerHeight)");
+      })
+      .sleep(200)
+      .then([](struct webview *w) { webview_set_fullscreen(w, 0); })
+      .sleep(500)
+      .then([](struct webview *w) {
+	webview_eval(w, "window.external.invoke(''+window.innerWidth+' ' + "
+			"window.innerHeight)");
+      })
+      .wait();
+  assert(results.size() == 4);
+  assert(results[1] == "480 320");
+  assert(results[0] == results[2]);
+  assert(results[1] == results[3]);
+}
+
+static void test_inject_js() {
+  struct webview w = {};
+  std::vector<std::string> results;
+  std::cout << "TEST: inject JS" << std::endl;
+  w.width = 480;
+  w.height = 320;
+  w.userdata = static_cast<void *>(&results);
+  w.external_invoke_cb = [](struct webview *w, const char *arg) {
+    auto *v = static_cast<std::vector<std::string> *>(w->userdata);
+    v->push_back(std::string(arg));
+  };
+  runner(&w)
+      .then([](struct webview *w) {
+	webview_eval(w,
+		     R"(document.body.innerHTML = '<div id="foo">Foo</div>';)");
+	webview_eval(
+	    w,
+	    "window.external.invoke(document.getElementById('foo').innerText)");
+      })
+      .wait();
+  assert(results.size() == 1);
+  assert(results[0] == "Foo");
+}
+
+static void test_inject_css() {
+  struct webview w = {};
+  std::vector<std::string> results;
+  std::cout << "TEST: inject CSS" << std::endl;
+  w.width = 480;
+  w.height = 320;
+  w.userdata = static_cast<void *>(&results);
+  w.external_invoke_cb = [](struct webview *w, const char *arg) {
+    auto *v = static_cast<std::vector<std::string> *>(w->userdata);
+    v->push_back(std::string(arg));
+  };
+  runner(&w)
+      .then([](struct webview *w) {
+	webview_inject_css(w, "#app { margin-left: 4px; }");
+	webview_eval(w, "window.external.invoke(getComputedStyle(document."
+			"getElementById('app')).marginLeft)");
+      })
+      .wait();
+  assert(results.size() == 1);
+  assert(results[0] == "4px");
+}
+
+int main() {
+  test_minimal();
+  test_window_size();
+  test_inject_js();
+  test_inject_css();
+  return 0;
+}