taigrr/wails
1
0
Fork 0
mirror of https://github.com/taigrr/wails.git synced 2026-04-02 05:08:54 -07:00
Code Issues Packages Projects Releases Wiki Activity

Develop (#250)

Browse Source
This commit is contained in:
Lea Anthony
2019-10-08 06:12:08 +11:00
committed by GitHub
parent 694f80434a
commit 20428b0407
123 changed files with 13212 additions and 1493 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
cmd/cmd-mewn.go
View File

File diff suppressed because one or more lines are too long

2
cmd/github.go
View File

@@ -18,7 +18,7 @@ func NewGitHubHelper() *GitHubHelper {
}
// GetVersionTags gets the list of tags on the Wails repo
// It retuns a list of sorted tags in descending order
// It returns a list of sorted tags in descending order
func (g *GitHubHelper) GetVersionTags() ([]*SemanticVersion, error) {
result := []*SemanticVersion{}

41
cmd/helpers.go
View File

@@ -9,7 +9,7 @@ import (
"runtime"
"time"
mewn "github.com/leaanthony/mewn"
"github.com/leaanthony/mewn"
"github.com/leaanthony/slicer"
"github.com/leaanthony/spinner"
)
@@ -249,8 +249,8 @@ func InstallFrontendDeps(projectDir string, projectOptions *ProjectOptions, forc
ioutil.WriteFile(md5sumFile, []byte(packageJSONMD5), 0644)
}
// Install the bridge library
err = InstallBridge(caller, projectDir, projectOptions)
// Install the runtime
err = InstallRuntime(caller, projectDir, projectOptions)
if err != nil {
return err
}
@@ -263,22 +263,29 @@ func InstallFrontendDeps(projectDir string, projectOptions *ProjectOptions, forc
return nil
}
// InstallBridge installs the relevant bridge javascript library
func InstallBridge(caller string, projectDir string, projectOptions *ProjectOptions) error {
bridgeFile := "wailsbridge.prod.js"
if caller == "serve" {
bridgeFile = "wailsbridge.js"
// InstallRuntime installs the correct runtime for the type of build
func InstallRuntime(caller string, projectDir string, projectOptions *ProjectOptions) error {
if caller == "build" {
return InstallProdRuntime(projectDir, projectOptions)
}
// Copy bridge to project
bridgeAssets := mewn.Group("../wailsruntimeassets/bridge/")
bridgeFileData := bridgeAssets.Bytes(bridgeFile)
bridgeFileTarget := filepath.Join(projectDir, projectOptions.FrontEnd.Dir, projectOptions.FrontEnd.Bridge, "wailsbridge.js")
err := fs.CreateFile(bridgeFileTarget, bridgeFileData)
if err != nil {
return err
}
return nil
return InstallBridge(projectDir, projectOptions)
}
// InstallBridge installs the relevant bridge javascript library
func InstallBridge(projectDir string, projectOptions *ProjectOptions) error {
bridgeFileData := mewn.String("../runtime/assets/bridge.js")
bridgeFileTarget := filepath.Join(projectDir, projectOptions.FrontEnd.Dir, "node_modules", "@wailsapp", "runtime", "init.js")
err := fs.CreateFile(bridgeFileTarget, []byte(bridgeFileData))
return err
}
// InstallProdRuntime installs the production runtime
func InstallProdRuntime(projectDir string, projectOptions *ProjectOptions) error {
prodInit := mewn.String("../runtime/js/runtime/init.js")
bridgeFileTarget := filepath.Join(projectDir, projectOptions.FrontEnd.Dir, "node_modules", "@wailsapp", "runtime", "init.js")
err := fs.CreateFile(bridgeFileTarget, []byte(prodInit))
return err
}
// ServeProject attempts to serve up the current project so that it may be connected to

236
cmd/linux.go
View File

@@ -17,110 +17,144 @@ type LinuxDistribution int
const (
// Unknown is the catch-all distro
Unknown LinuxDistribution = iota
// Debian distribution
Debian
// Ubuntu distribution
Ubuntu
// Arch linux distribution
Arch
// RedHat linux distribution
RedHat
// Debian distribution
Debian
// CentOS linux distribution
CentOS
// Fedora linux distribution
Fedora
// Gentoo distribution
Gentoo
// Zorin distribution
Zorin
// Parrot distribution
Parrot
// Linuxmint distribution
Linuxmint
// VoidLinux distribution
VoidLinux
// Elementary distribution
Elementary
// Kali distribution
Kali
// Neon distribution
Neon
// Manjaro distribution
Manjaro
)
// DistroInfo contains all the information relating to a linux distribution
type DistroInfo struct {
Distribution LinuxDistribution
Description string
Release string
Codename string
DistributorID string
DiscoveredBy string
Distribution LinuxDistribution
Name string
ID string
Description string
Release string
}
// GetLinuxDistroInfo returns information about the running linux distribution
func GetLinuxDistroInfo() *DistroInfo {
result := &DistroInfo{Distribution: Unknown}
program := NewProgramHelper()
// Does lsb_release exist?
lsbRelease := program.FindProgram("lsb_release")
if lsbRelease != nil {
stdout, _, _, err := lsbRelease.Run("-a")
if err != nil {
return result
}
result.DiscoveredBy = "lsb"
for _, line := range strings.Split(stdout, "\n") {
if strings.Contains(line, ":") {
// Iterate lines a
details := strings.Split(line, ":")
key := strings.TrimSpace(details[0])
value := strings.TrimSpace(details[1])
switch key {
case "Distributor ID":
result.DistributorID = value
switch value {
case "Ubuntu":
result.Distribution = Ubuntu
case "Arch", "ManjaroLinux":
result.Distribution = Arch
case "Debian":
result.Distribution = Debian
}
case "Description":
result.Description = value
case "Release":
result.Release = value
case "Codename":
result.Codename = value
}
}
}
// check if /etc/os-release exists
} else if _, err := os.Stat("/etc/os-release"); !os.IsNotExist(err) {
// Default value
osName := "Unknown"
version := ""
// read /etc/os-release
result := &DistroInfo{
Distribution: Unknown,
ID: "unknown",
Name: "Unknown",
}
_, err := os.Stat("/etc/os-release")
if !os.IsNotExist(err) {
osRelease, _ := ioutil.ReadFile("/etc/os-release")
// Split into lines
lines := strings.Split(string(osRelease), "\n")
// Iterate lines
for _, line := range lines {
// Split each line by the equals char
splitLine := strings.SplitN(line, "=", 2)
// Check we have
if len(splitLine) != 2 {
continue
}
switch splitLine[0] {
case "NAME":
osName = strings.Trim(splitLine[1], "\"")
case "VERSION_ID":
version = strings.Trim(splitLine[1], "\"")
}
}
// Check distro name against list of distros
result.Release = version
result.DiscoveredBy = "os-release"
switch osName {
case "Fedora":
result.Distribution = RedHat
case "CentOS":
result.Distribution = RedHat
case "Arch Linux":
result.Distribution = Arch
case "Debian GNU/Linux":
result.Distribution = Debian
default:
result.Distribution = Unknown
result.DistributorID = osName
}
result = parseOsRelease(string(osRelease))
}
return result
}
// parseOsRelease parses the given os-release data and returns
// a DistroInfo struct with the details
func parseOsRelease(osRelease string) *DistroInfo {
result := &DistroInfo{Distribution: Unknown}
// Default value
osID := "unknown"
osNAME := "Unknown"
version := ""
// Split into lines
lines := strings.Split(osRelease, "\n")
// Iterate lines
for _, line := range lines {
// Split each line by the equals char
splitLine := strings.SplitN(line, "=", 2)
// Check we have
if len(splitLine) != 2 {
continue
}
switch splitLine[0] {
case "ID":
osID = strings.Trim(splitLine[1], "\"")
case "NAME":
osNAME = strings.Trim(splitLine[1], "\"")
case "VERSION_ID":
version = strings.Trim(splitLine[1], "\"")
}
}
// Check distro name against list of distros
switch osID {
case "fedora":
result.Distribution = Fedora
case "centos":
result.Distribution = CentOS
case "arch":
result.Distribution = Arch
case "debian":
result.Distribution = Debian
case "ubuntu":
result.Distribution = Ubuntu
case "gentoo":
result.Distribution = Gentoo
case "zorin":
result.Distribution = Zorin
case "parrot":
result.Distribution = Parrot
case "linuxmint":
result.Distribution = Linuxmint
case "void":
result.Distribution = VoidLinux
case "elementary":
result.Distribution = Elementary
case "kali":
result.Distribution = Kali
case "neon":
result.Distribution = Neon
case "manjaro":
result.Distribution = Manjaro
default:
result.Distribution = Unknown
}
result.Name = osNAME
result.ID = osID
result.Release = version
return result
}
// CheckPkgInstalled is all functions that use local programs to see if a package is installed
type CheckPkgInstalled func(string) (bool, error)
// EqueryInstalled uses equery to see if a package is installed
func EqueryInstalled(packageName string) (bool, error) {
program := NewProgramHelper()
equery := program.FindProgram("equery")
if equery == nil {
return false, fmt.Errorf("cannont check dependencies: equery not found")
}
_, _, exitCode, _ := equery.Run("l", packageName)
return exitCode == 0, nil
}
// DpkgInstalled uses dpkg to see if a package is installed
func DpkgInstalled(packageName string) (bool, error) {
program := NewProgramHelper()
@@ -143,6 +177,17 @@ func PacmanInstalled(packageName string) (bool, error) {
return exitCode == 0, nil
}
// XbpsInstalled uses pacman to see if a package is installed.
func XbpsInstalled(packageName string) (bool, error) {
program := NewProgramHelper()
xbpsQuery := program.FindProgram("xbps-query")
if xbpsQuery == nil {
return false, fmt.Errorf("cannot check dependencies: xbps-query not found")
}
_, _, exitCode, _ := xbpsQuery.Run("-S", packageName)
return exitCode == 0, nil
}
// RpmInstalled uses rpm to see if a package is installed
func RpmInstalled(packageName string) (bool, error) {
program := NewProgramHelper()
@@ -156,18 +201,18 @@ func RpmInstalled(packageName string) (bool, error) {
// RequestSupportForDistribution promts the user to submit a request to support their
// currently unsupported distribution
func RequestSupportForDistribution(distroInfo *DistroInfo, libraryName string) error {
func RequestSupportForDistribution(distroInfo *DistroInfo) error {
var logger = NewLogger()
defaultError := fmt.Errorf("unable to check libraries on distribution '%s'. Please ensure that the '%s' equivalent is installed", distroInfo.DistributorID, libraryName)
defaultError := fmt.Errorf("unable to check libraries on distribution '%s'", distroInfo.Name)
logger.Yellow("Distribution '%s' is not currently supported, but we would love to!", distroInfo.DistributorID)
q := fmt.Sprintf("Would you like to submit a request to support distribution '%s'?", distroInfo.DistributorID)
logger.Yellow("Distribution '%s' is not currently supported, but we would love to!", distroInfo.Name)
q := fmt.Sprintf("Would you like to submit a request to support distribution '%s'?", distroInfo.Name)
result := Prompt(q, "yes")
if strings.ToLower(result) != "yes" {
return defaultError
}
title := fmt.Sprintf("Support Distribution '%s'", distroInfo.DistributorID)
title := fmt.Sprintf("Support Distribution '%s'", distroInfo.Name)
var str strings.Builder
@@ -182,16 +227,15 @@ func RequestSupportForDistribution(distroInfo *DistroInfo, libraryName string) e
str.WriteString(fmt.Sprintf("| Platform | %s |\n", runtime.GOOS))
str.WriteString(fmt.Sprintf("| Arch | %s |\n", runtime.GOARCH))
str.WriteString(fmt.Sprintf("| GO111MODULE | %s |\n", gomodule))
str.WriteString(fmt.Sprintf("| Distribution ID | %s |\n", distroInfo.DistributorID))
str.WriteString(fmt.Sprintf("| Distribution ID | %s |\n", distroInfo.ID))
str.WriteString(fmt.Sprintf("| Distribution Name | %s |\n", distroInfo.Name))
str.WriteString(fmt.Sprintf("| Distribution Version | %s |\n", distroInfo.Release))
str.WriteString(fmt.Sprintf("| Discovered by | %s |\n", distroInfo.DiscoveredBy))
body := fmt.Sprintf("**Description**\nDistribution '%s' is currently unsupported.\n\n**Further Information**\n\n%s\n\n*Please add any extra information here, EG: libraries that are needed to make the distribution work, or commands to install them*", distroInfo.DistributorID, str.String())
body := fmt.Sprintf("**Description**\nDistribution '%s' is currently unsupported.\n\n**Further Information**\n\n%s\n\n*Please add any extra information here, EG: libraries that are needed to make the distribution work, or commands to install them*", distroInfo.ID, str.String())
fullURL := "https://github.com/wailsapp/wails/issues/new?"
params := "title=" + title + "&body=" + body
fmt.Println("Opening browser to file request.")
browser.OpenURL(fullURL + url.PathEscape(params))
return nil
}

26
cmd/linux_test.go Normal file
View File

@@ -0,0 +1,26 @@
package cmd
import "testing"
func TestUbuntuDetection(t *testing.T) {
osrelease := `
NAME="Ubuntu"
VERSION="18.04.2 LTS (Bionic Beaver)"
ID=ubuntu
ID_LIKE=debian
PRETTY_NAME="Ubuntu 18.04.2 LTS"
VERSION_ID="18.04"
HOME_URL="https://www.ubuntu.com/"
SUPPORT_URL="https://help.ubuntu.com/"
BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
VERSION_CODENAME=bionic
UBUNTU_CODENAME=bionic
`
result := parseOsRelease(osrelease)
if result.Distribution != Ubuntu {
t.Errorf("expected 'Ubuntu' ID but got '%d'", result.Distribution)
}
}

91
cmd/linuxdb.go Normal file
View File

@@ -0,0 +1,91 @@
package cmd
import (
"log"
"github.com/leaanthony/mewn"
"gopkg.in/yaml.v3"
)
// LinuxDB is the database for linux distribution data.
type LinuxDB struct {
Distributions map[string]*Distribution `yaml:"distributions"`
}
// Distribution holds the os-release ID and a map of releases.
type Distribution struct {
ID string `yaml:"id"`
Releases map[string]*Release `yaml:"releases"`
}
// GetRelease attempts to return the specific Release information
// for the given release name. If there is no specific match, the
// default release data is returned.
func (d *Distribution) GetRelease(version string) *Release {
result := d.Releases[version]
if result == nil {
result = d.Releases["default"]
}
return result
}
// Release holds the name and version of the release as given by
// os-release. Programs is a slice of dependant programs required
// to be present on the local installation for Wails to function.
// Libraries is a slice of libraries that must be present for Wails
// applications to compile.
type Release struct {
Name string `yaml:"name"`
Version string `yaml:"version"`
GccVersionCommand string `yaml:"gccversioncommand"`
Programs []*Prerequisite `yaml:"programs"`
Libraries []*Prerequisite `yaml:"libraries"`
}
// Prerequisite is a simple struct containing a program/library name
// plus the distribution specific help text indicating how to install
// it.
type Prerequisite struct {
Name string `yaml:"name"`
Help string `yaml:"help,omitempty"`
}
// Load will load the given filename from disk and attempt to
// import the data into the LinuxDB.
func (l *LinuxDB) Load(filename string) error {
if fs.FileExists(filename) {
data, err := fs.LoadAsBytes(filename)
if err != nil {
return err
}
return l.ImportData(data)
}
return nil
}
// ImportData will unmarshal the given YAML formatted data
// into the LinuxDB
func (l *LinuxDB) ImportData(data []byte) error {
return yaml.Unmarshal(data, l)
}
// GetDistro returns the Distribution information for the
// given distribution name. If the distribution is not supported,
// nil is returned.
func (l *LinuxDB) GetDistro(distro string) *Distribution {
return l.Distributions[distro]
}
// NewLinuxDB creates a new LinuxDB instance from the bundled
// linuxdb.yaml file.
func NewLinuxDB() *LinuxDB {
data := mewn.Bytes("./linuxdb.yaml")
result := LinuxDB{
Distributions: make(map[string]*Distribution),
}
err := result.ImportData(data)
if err != nil {
log.Fatal(err)
}
return &result
}

188
cmd/linuxdb.yaml Normal file
View File

@@ -0,0 +1,188 @@
---
distributions:
debian:
id: debian
releases:
default:
name: Debian
version: default
gccversioncommand: &gccdumpversion -dumpversion
programs: &debiandefaultprograms
- name: gcc
help: Please install with `sudo apt-get install build-essential` and try again
- name: pkg-config
help: Please install with `sudo apt-get install pkg-config` and try again
- name: npm
help: Please install with `curl -sL https://deb.nodesource.com/setup_12.x | sudo bash - && sudo apt-get install -y nodejs` and try again
libraries: &debiandefaultlibraries
- name: libgtk-3-dev
help: Please install with `sudo apt-get install libgtk-3-dev` and try again
- name: libwebkit2gtk-4.0-dev
help: Please install with `sudo apt-get install libwebkit2gtk-4.0-dev` and try again
ubuntu:
id: ubuntu
releases:
default:
version: default
name: Ubuntu
gccversioncommand: &gccdumpfullversion -dumpfullversion
programs: *debiandefaultprograms
libraries: *debiandefaultlibraries
kali:
id: kali
releases:
default:
version: default
name: Kali GNU/Linux
gccversioncommand: *gccdumpfullversion
programs: *debiandefaultprograms
libraries: *debiandefaultlibraries
parrot:
id: parrot
releases:
default:
version: default
name: Parrot GNU/Linux
gccversioncommand: *gccdumpversion
programs: *debiandefaultprograms
libraries: *debiandefaultlibraries
zorin:
id: zorin
releases:
default:
version: default
name: Zorin
gccversioncommand: *gccdumpversion
programs: *debiandefaultprograms
libraries: *debiandefaultlibraries
linuxmint:
id: linuxmint
releases:
default:
version: default
name: Linux Mint
gccversioncommand: *gccdumpversion
programs: *debiandefaultprograms
libraries: *debiandefaultlibraries
elementary:
id: elementary
releases:
default:
version: default
name: elementary OS
gccversioncommand: *gccdumpfullversion
programs: *debiandefaultprograms
libraries: *debiandefaultlibraries
neon:
id: neon
releases:
default:
version: default
name: KDE neon
gccversioncommand: *gccdumpfullversion
programs: *debiandefaultprograms
libraries: *debiandefaultlibraries
void:
id: void
releases:
default:
version: default
name: VoidLinux
gccversioncommand: *gccdumpversion
programs:
- name: gcc
help: Please install with `xbps-install base-devel` and try again
- name: pkg-config
help: Please install with `xbps-install pkg-config` and try again
- name: npm
help: Please install with `xbps-install nodejs` and try again
libraries:
- name: gtk+3-devel
help: Please install with `xbps-install gtk+3-devel` and try again
- name: webkit2gtk-devel
help: Please install with `xbps-install webkit2gtk-devel` and try again
centos:
id: centos
releases:
default:
version: default
name: CentOS Linux
gccversioncommand: *gccdumpversion
programs:
- name: gcc
help: Please install with `sudo yum install gcc-c++ make` and try again
- name: pkg-config
help: Please install with `sudo yum install pkgconf-pkg-config` and try again
- name: npm
help: Please install with `sudo yum install epel-release && sudo yum install nodejs` and try again
libraries:
- name: gtk3-devel
help: Please install with `sudo yum install gtk3-devel` and try again
- name: webkitgtk3-devel
help: Please install with `sudo yum install webkitgtk3-devel` and try again
fedora:
id: fedora
releases:
default:
version: default
name: Fedora
gccversioncommand: *gccdumpfullversion
programs:
- name: gcc
help: Please install with `sudo yum install gcc-c++ make` and try again
- name: pkg-config
help: Please install with `sudo yum install pkgconf-pkg-config` and try again
- name: npm
help: Please install `sudo yum install nodejs` and try again
libraries:
- name: gtk3-devel
help: Please install with `sudo yum install gtk3-devel` and try again
- name: webkit2gtk3-devel
help: Please install with `sudo yum install webkit2gtk3-devel` and try again
arch:
id: arch
releases:
default:
version: default
name: Arch Linux
gccversioncommand: *gccdumpversion
programs: &archdefaultprograms
- name: gcc
help: Please install with `sudo pacman -S gcc` and try again
- name: pkgconf
help: Please install with `sudo pacman -S pkgconf` and try again
- name: npm
help: Please install with `sudo pacman -S npm` and try again
libraries: &archdefaultlibraries
- name: gtk3
help: Please install with `sudo pacman -S gtk3` and try again
- name: webkit2gtk
help: Please install with `sudo pacman -S webkit2gtk` and try again
manjaro:
id: manjaro
releases:
default:
version: default
name: Manjaro Linux
gccversioncommand: *gccdumpversion
programs: *archdefaultprograms
libraries: *archdefaultlibraries
gentoo:
id: gentoo
releases:
default:
version: default
name: Gentoo
gccversioncommand: *gccdumpversion
programs:
- name: gcc
help: Please install using your system's package manager
- name: pkg-config
help: Please install using your system's package manager
- name: npm
help: Please install using your system's package manager
libraries:
- name: gtk+:3
help: Please install with `sudo emerge gtk+:3` and try again
- name: webkit-gtk
help: Please install with `sudo emerge webkit-gtk` and try again

81
cmd/linuxdb_test.go Normal file
View File

@@ -0,0 +1,81 @@
package cmd
import "testing"
func TestNewLinuxDB(t *testing.T) {
_ = NewLinuxDB()
}
func TestKnownDistro(t *testing.T) {
var linuxDB = NewLinuxDB()
result := linuxDB.GetDistro("ubuntu")
if result == nil {
t.Error("Cannot get distro 'ubuntu'")
}
}
func TestUnknownDistro(t *testing.T) {
var linuxDB = NewLinuxDB()
result := linuxDB.GetDistro("unknown")
if result != nil {
t.Error("Should get nil for distribution 'unknown'")
}
}
func TestDefaultRelease(t *testing.T) {
var linuxDB = NewLinuxDB()
result := linuxDB.GetDistro("ubuntu")
if result == nil {
t.Error("Cannot get distro 'ubuntu'")
}
release := result.GetRelease("default")
if release == nil {
t.Error("Cannot get release 'default' for distro 'ubuntu'")
}
}
func TestUnknownRelease(t *testing.T) {
var linuxDB = NewLinuxDB()
result := linuxDB.GetDistro("ubuntu")
if result == nil {
t.Error("Cannot get distro 'ubuntu'")
}
release := result.GetRelease("16.04")
if release == nil {
t.Error("Failed to get release 'default' for unknown release version '16.04'")
}
if release.Version != "default" {
t.Errorf("Got version '%s' instead of 'default' for unknown release version '16.04'", result.ID)
}
}
func TestGetPrerequisites(t *testing.T) {
var linuxDB = NewLinuxDB()
result := linuxDB.GetDistro("debian")
if result == nil {
t.Error("Cannot get distro 'debian'")
}
release := result.GetRelease("default")
if release == nil {
t.Error("Failed to get release 'default' for unknown release version '16.04'")
}
if release.Version != "default" {
t.Errorf("Got version '%s' instead of 'default' for unknown release version '16.04'", result.ID)
}
if release.Name != "Debian" {
t.Errorf("Got Release Name '%s' instead of 'debian' for unknown release version '16.04'", release.Name)
}
if len(release.Programs) != 3 {
t.Errorf("Expected %d programs for unknown release version '16.04'", len(release.Programs))
}
if len(release.Libraries) != 2 {
t.Errorf("Expected %d libraries for unknown release version '16.04'", len(release.Libraries))
}
}

45
cmd/prerequisites.go
View File

@@ -5,13 +5,6 @@ import (
"runtime"
)
// Prerequisite defines a Prerequisite!
type Prerequisite struct {
Name string
Help string
Path string
}
func newPrerequisite(name, help string) *Prerequisite {
return &Prerequisite{Name: name, Help: help}
}
@@ -48,16 +41,13 @@ func getRequiredProgramsOSX() *Prerequisites {
func getRequiredProgramsLinux() *Prerequisites {
result := &Prerequisites{}
distroInfo := GetLinuxDistroInfo()
switch distroInfo.Distribution {
case Ubuntu, Debian:
result.Add(newPrerequisite("gcc", "Please install with `sudo apt install build-essentials` and try again"))
result.Add(newPrerequisite("pkg-config", "Please install with `sudo apt install pkg-config` and try again"))
result.Add(newPrerequisite("npm", "Please install with `sudo snap install node --channel=12/stable --classic` and try again"))
default:
result.Add(newPrerequisite("gcc", "Please install with your system package manager and try again"))
result.Add(newPrerequisite("pkg-config", "Please install with your system package manager and try again"))
result.Add(newPrerequisite("npm", "Please install from https://nodejs.org/en/download/ and try again"))
if distroInfo.Distribution != Unknown {
var linuxDB = NewLinuxDB()
distro := linuxDB.GetDistro(distroInfo.ID)
release := distro.GetRelease(distroInfo.Release)
for _, program := range release.Programs {
result.Add(program)
}
}
return result
}
@@ -91,20 +81,15 @@ func getRequiredLibrariesOSX() (*Prerequisites, error) {
func getRequiredLibrariesLinux() (*Prerequisites, error) {
result := &Prerequisites{}
// The Linux Distribution DB
distroInfo := GetLinuxDistroInfo()
switch distroInfo.Distribution {
case Ubuntu:
result.Add(newPrerequisite("libgtk-3-dev", "Please install with `sudo apt install libgtk-3-dev` and try again"))
result.Add(newPrerequisite("libwebkit2gtk-4.0-dev", "Please install with `sudo apt install libwebkit2gtk-4.0-dev` and try again"))
case Arch:
result.Add(newPrerequisite("gtk3", "Please install with `sudo pacman -S gtk3` and try again"))
result.Add(newPrerequisite("webkit2gtk", "Please install with `sudo pacman -S webkit2gtk` and try again"))
case RedHat:
result.Add(newPrerequisite("gtk3-devel", "Please install with `sudo yum install gtk3-devel` and try again"))
result.Add(newPrerequisite("webkit2gtk3-devel", "Please install with `sudo yum install webkit2gtk3-devel` and try again"))
default:
result.Add(newPrerequisite("libgtk-3-dev", "Please install with your system package manager and try again"))
result.Add(newPrerequisite("libwebkit2gtk-4.0-dev", "Please install with your system package manager and try again"))
if distroInfo.Distribution != Unknown {
var linuxDB = NewLinuxDB()
distro := linuxDB.GetDistro(distroInfo.ID)
release := distro.GetRelease(distroInfo.Release)
for _, library := range release.Libraries {
result.Add(library)
}
}
return result, nil
}

7
cmd/program.go
View File

@@ -117,14 +117,15 @@ func (p *ProgramHelper) RunCommandArray(args []string, dir ...string) error {
}
args = args[1:]
var stderr string
// fmt.Printf("RunCommandArray = %s %+v\n", program, args)
var stdout string
if len(dir) > 0 {
_, stderr, err = p.shell.RunInDirectory(dir[0], program, args...)
stdout, stderr, err = p.shell.RunInDirectory(dir[0], program, args...)
} else {
_, stderr, err = p.shell.Run(program, args...)
stdout, stderr, err = p.shell.Run(program, args...)
}
if err != nil {
fmt.Println(stderr)
fmt.Println(stdout)
}
return err
}

6
cmd/project.go
View File

@@ -112,9 +112,9 @@ func (ph *ProjectHelper) NewProjectOptions() *ProjectOptions {
Description: "Enter your project description",
Version: "0.1.0",
BinaryName: "",
system: NewSystemHelper(),
log: NewLogger(),
templates: NewTemplateHelper(),
system: ph.system,
log: ph.log,
templates: ph.templates,
Author: &author{},
}

7
cmd/prompt.go
View File

@@ -4,7 +4,6 @@ import (
"bufio"
"fmt"
"os"
"runtime"
"strconv"
"strings"
)
@@ -20,11 +19,7 @@ func Prompt(question string, defaultValue ...string) string {
fmt.Printf(question + ": ")
reader := bufio.NewReader(os.Stdin)
input, _ := reader.ReadString('\n')
EOL := "\n"
if runtime.GOOS == "windows" {
EOL = "\r\n"
}
input = strings.Replace(input, EOL, "", -1)
input = strings.TrimSpace(input)
if input != "" {
answer = input

63
cmd/system.go
View File

@@ -269,44 +269,35 @@ func CheckDependencies(logger *Logger) (bool, error) {
if err != nil {
return false, err
}
var libraryChecker CheckPkgInstalled
distroInfo := GetLinuxDistroInfo()
switch distroInfo.Distribution {
case Ubuntu, Debian, Zorin, Parrot, Linuxmint, Elementary, Kali, Neon:
libraryChecker = DpkgInstalled
case Arch, Manjaro:
libraryChecker = PacmanInstalled
case CentOS, Fedora:
libraryChecker = RpmInstalled
case Gentoo:
libraryChecker = EqueryInstalled
case VoidLinux:
libraryChecker = XbpsInstalled
default:
return false, RequestSupportForDistribution(distroInfo)
}
for _, library := range *requiredLibraries {
switch distroInfo.Distribution {
case Ubuntu, Debian:
installed, err := DpkgInstalled(library.Name)
if err != nil {
return false, err
}
if !installed {
errors = true
logger.Error("Library '%s' not found. %s", library.Name, library.Help)
} else {
logger.Green("Library '%s' installed.", library.Name)
}
case Arch:
installed, err := PacmanInstalled(library.Name)
if err != nil {
return false, err
}
if !installed {
errors = true
logger.Error("Library '%s' not found. %s", library.Name, library.Help)
} else {
logger.Green("Library '%s' installed.", library.Name)
}
case RedHat:
installed, err := RpmInstalled(library.Name)
if err != nil {
return false, err
}
if !installed {
errors = true
logger.Error("Library '%s' not found. %s", library.Name, library.Help)
} else {
logger.Green("Library '%s' installed.", library.Name)
}
default:
return false, RequestSupportForDistribution(distroInfo, library.Name)
installed, err := libraryChecker(library.Name)
if err != nil {
return false, err
}
if !installed {
errors = true
logger.Error("Library '%s' not found. %s", library.Name, library.Help)
} else {
logger.Green("Library '%s' installed.", library.Name)
}
}
}

2
cmd/templates.go
View File

@@ -67,7 +67,7 @@ func NewTemplateHelper() *TemplateHelper {
}
}
// IsValidTemplate returns true if the given tempalte name resides on disk
// IsValidTemplate returns true if the given template name resides on disk
func (t *TemplateHelper) IsValidTemplate(templateName string) bool {
pathToTemplate := filepath.Join(t.templateDir.fullPath, templateName)
return t.fs.DirExists(pathToTemplate)

1
cmd/templates/angular-template/frontend/package.json.template
View File

@@ -21,6 +21,7 @@
"@angular/platform-browser": "~8.0.1",
"@angular/platform-browser-dynamic": "~8.0.1",
"@angular/router": "~8.0.1",
"@wailsapp/runtime": "^1.0.0",
"ngx-build-plus": "^8.0.3",
"rxjs": "~6.4.0",
"tslib": "^1.9.0",

4
cmd/templates/angular-template/frontend/src/main.ts
View File

@@ -6,13 +6,13 @@ import { environment } from './environments/environment';
import 'zone.js'
import Bridge from './wailsbridge';
import Wails from '@wailsapp/runtime';
if (environment.production) {
enableProdMode();
}
Bridge.Start(() => {
Wails.Init(() => {
platformBrowserDynamic().bootstrapModule(AppModule)
.catch(err => console.error(err));
});

4
cmd/templates/create-react-app/frontend/package.json.template
View File

@@ -4,10 +4,12 @@
"version": "0.1.0",
"private": true,
"dependencies": {
"core-js": "^3.1.4",
"react": "^16.8.6",
"react-dom": "^16.8.6",
"wails-react-scripts": "3.0.1-2",
"react-modal": "3.8.1"
"react-modal": "3.8.1",
"@wailsapp/runtime": "^1.0.0"
},
"scripts": {
"start": "react-scripts start",

5
cmd/templates/create-react-app/frontend/src/index.js
View File

@@ -1,10 +1,11 @@
import React from 'react';
import ReactDOM from 'react-dom';
import 'core-js/stable';
import './index.css';
import App from './App';
import Bridge from "./wailsbridge";
import Wails from '@wailsapp/runtime';
Bridge.Start(() => {
Wails.Init(() => {
ReactDOM.render(<App />, document.getElementById('app'));
});

3
cmd/templates/vuebasic/frontend/package.json.template
View File

@@ -9,7 +9,8 @@
},
"dependencies": {
"core-js": "^2.6.4",
"vue": "^2.5.22"
"vue": "^2.5.22",
"@wailsapp/runtime": "^1.0.0"
},
"devDependencies": {
"@vue/cli-plugin-babel": "^3.4.0",

14
cmd/templates/vuebasic/frontend/src/main.js
View File

@@ -1,13 +1,13 @@
import Vue from "vue";
import App from "./App.vue";
import Vue from 'vue';
import App from './App.vue';
Vue.config.productionTip = false;
Vue.config.devtools = true;
import Bridge from "./wailsbridge";
import Wails from '@wailsapp/runtime';
Bridge.Start(() => {
new Vue({
render: h => h(App)
}).$mount("#app");
Wails.Init(() => {
new Vue({
render: h => h(App)
}).$mount('#app');
});

17
cmd/templates/vuebasic/frontend/src/wailsbridge.js
View File

@@ -1,17 +0,0 @@
/*
Wails Bridge (c) 2019-present Lea Anthony
This prod version is to get around having to rewrite your code
for production. When doing a release build, this file will be used
instead of the full version.
*/
export default {
// The main function
// Passes the main Wails object to the callback if given.
Start: function (callback) {
if (callback) {
window.wails.Events.On("wails:ready", callback);
}
}
};

3
cmd/templates/vuetify-basic/frontend/package.json.template
View File

@@ -12,7 +12,8 @@
"core-js": "^2.6.4",
"material-design-icons-iconfont": "^5.0.1",
"vue": "^2.5.22",
"vuetify": "^1.5.14"
"vuetify": "^1.5.14",
"@wailsapp/runtime": "^1.0.0"
},
"devDependencies": {
"@vue/cli-plugin-babel": "^3.4.0",

14
cmd/templates/vuetify-basic/frontend/src/main.js
View File

@@ -1,5 +1,5 @@
import 'babel-polyfill';
import Vue from "vue";
import Vue from 'vue';
// Setup Vuetify
import Vuetify from 'vuetify';
@@ -7,15 +7,15 @@ Vue.use(Vuetify);
import 'vuetify/dist/vuetify.min.css';
import 'material-design-icons-iconfont';
import App from "./App.vue";
import App from './App.vue';
Vue.config.productionTip = false;
Vue.config.devtools = true;
import Bridge from "./wailsbridge";
import Wails from '@wailsapp/runtime';
Bridge.Start(() => {
new Vue({
render: h => h(App)
}).$mount("#app");
Wails.Init(() => {
new Vue({
render: h => h(App)
}).$mount('#app');
});

2
cmd/version.go
View File

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

91
cmd/wails/0_setup.go
View File

@@ -1,7 +1,6 @@
package main
import (
"fmt"
"runtime"
"github.com/wailsapp/wails/cmd"
@@ -24,7 +23,7 @@ func init() {
system := cmd.NewSystemHelper()
err = system.Initialise()
if err == nil {
if err != nil {
return err
}
@@ -33,23 +32,9 @@ Create your first project by running 'wails init'.`
if runtime.GOOS != "windows" {
successMessage = "🚀 " + successMessage
}
// Platform check
err = platformCheck()
if err != nil {
return err
}
// Check we have a cgo capable environment
logger.Yellow("Checking for prerequisites...")
var requiredProgramErrors bool
requiredProgramErrors, err = checkRequiredPrograms()
if err != nil {
return err
}
// Linux has library deps
var libraryErrors bool
libraryErrors, err = checkLibraries()
// Chrck for programs and libraries dependencies
errors, err := cmd.CheckDependencies(logger)
if err != nil {
return err
}
@@ -60,76 +45,14 @@ Create your first project by running 'wails init'.`
return err
}
logger.White("")
// Check for errors
var errors = libraryErrors || requiredProgramErrors
if !errors {
// CheckDependencies() returns !errors
// so to get the right message in this
// check we have to do it in reversed
if errors {
logger.Yellow(successMessage)
}
return err
})
}
func platformCheck() error {
switch runtime.GOOS {
case "darwin":
logger.Yellow("Detected Platform: OSX")
case "windows":
logger.Yellow("Detected Platform: Windows")
case "linux":
logger.Yellow("Detected Platform: Linux")
default:
return fmt.Errorf("Platform %s is currently not supported", runtime.GOOS)
}
return nil
}
func checkLibraries() (errors bool, err error) {
if runtime.GOOS == "linux" {
// Check library prerequisites
requiredLibraries, err := cmd.GetRequiredLibraries()
if err != nil {
return false, err
}
distroInfo := cmd.GetLinuxDistroInfo()
for _, library := range *requiredLibraries {
switch distroInfo.Distribution {
case cmd.Ubuntu, cmd.Debian:
installed, err := cmd.DpkgInstalled(library.Name)
if err != nil {
return false, err
}
if !installed {
errors = true
logger.Red("Library '%s' not found. %s", library.Name, library.Help)
} else {
logger.Green("Library '%s' installed.", library.Name)
}
default:
return false, cmd.RequestSupportForDistribution(distroInfo, library.Name)
}
}
}
return false, nil
}
func checkRequiredPrograms() (errors bool, err error) {
requiredPrograms, err := cmd.GetRequiredPrograms()
if err != nil {
return true, err
}
errors = false
programHelper := cmd.NewProgramHelper()
for _, program := range *requiredPrograms {
bin := programHelper.FindProgram(program.Name)
if bin == nil {
errors = true
logger.Red("Program '%s' not found. %s", program.Name, program.Help)
} else {
logger.Green("Program '%s' found: %s", program.Name, bin.Path)
}
}
return
}

9
cmd/wails/4_build.go
View File

@@ -72,8 +72,17 @@ func init() {
if err != nil {
return err
}
// Ensure that runtime init.js is the production version
err = cmd.InstallProdRuntime(projectDir, projectOptions)
if err != nil {
return err
}
}
// Move to project directory
err = os.Chdir(projectDir)
if err != nil {

2
cmd/wails/6_serve.go
View File

@@ -45,7 +45,7 @@ func init() {
projectDir := fs.Cwd()
// Install the bridge library
err = cmd.InstallBridge("serve", projectDir, projectOptions)
err = cmd.InstallBridge(projectDir, projectOptions)
if err != nil {
return err
}

52
cmd/wails/9_issue.go
View File

@@ -42,12 +42,64 @@ To help you in this process, we will ask for some information, add Go/Wails deta
gomodule = "(Not Set)"
}
// get version numbers for GCC, node & npm
program := cmd.NewProgramHelper()
// string helpers
var gccVersion, nodeVersion, npmVersion string
// choose between OS (mac,linux,win)
switch runtime.GOOS {
case "darwin":
gcc := program.FindProgram("gcc")
if gcc != nil {
stdout, _, _, _ := gcc.Run("-dumpversion")
gccVersion = strings.TrimSpace(stdout)
}
case "linux":
// for linux we have to collect
// the distribution name
distroInfo := cmd.GetLinuxDistroInfo()
linuxDB := cmd.NewLinuxDB()
distro := linuxDB.GetDistro(distroInfo.ID)
release := distro.GetRelease(distroInfo.Release)
gccVersionCommand := release.GccVersionCommand
gcc := program.FindProgram("gcc")
if gcc != nil {
stdout, _, _, _ := gcc.Run(gccVersionCommand)
gccVersion = strings.TrimSpace(stdout)
}
case "windows":
gcc := program.FindProgram("gcc")
if gcc != nil {
stdout, _, _, _ := gcc.Run("-dumpversion")
gccVersion = strings.TrimSpace(stdout)
}
}
npm := program.FindProgram("npm")
if npm != nil {
stdout, _, _, _ := npm.Run("--version")
nodeVersion = stdout
nodeVersion = nodeVersion[:len(nodeVersion)-1]
}
node := program.FindProgram("node")
if node != nil {
stdout, _, _, _ := node.Run("--version")
npmVersion = stdout
npmVersion = npmVersion[:len(npmVersion)-1]
}
str.WriteString("\n| Name | Value |\n| ----- | ----- |\n")
str.WriteString(fmt.Sprintf("| Wails Version | %s |\n", cmd.Version))
str.WriteString(fmt.Sprintf("| Go Version | %s |\n", runtime.Version()))
str.WriteString(fmt.Sprintf("| Platform | %s |\n", runtime.GOOS))
str.WriteString(fmt.Sprintf("| Arch | %s |\n", runtime.GOARCH))
str.WriteString(fmt.Sprintf("| GO111MODULE | %s |\n", gomodule))
str.WriteString(fmt.Sprintf("| GCC | %s |\n", gccVersion))
str.WriteString(fmt.Sprintf("| Npm | %s |\n", npmVersion))
str.WriteString(fmt.Sprintf("| Node | %s |\n", nodeVersion))
fmt.Println()
fmt.Println("Processing template and preparing for upload.")