text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>package main
import (
"context"
"embed"
"github.com/wailsapp/wails/<|fim_suffix|>p.Window.New().
SetTitle("WebviewWindow 1").
Show()
// Create a custom menu
menu := app.NewMenu()
if runtime.GOOS == "darwin" {
menu.AddRole(application.AppMenu)
}
windowCounter := 1
// Let's make a "Demo" ... | fim | wailsapp/wails | go |
<|fim_prefix|>package main
import (
"embed"
"github.com/wailsapp/wails/v3/pkg/application"
"log"
)
//go:embed assets/*
var assets embed.FS
func main() {
app := application.New(application.Options{
Name: "Window MenuBar Demo",
Description: "A demo of menu bar toggling",
Assets: application.AssetOpti... | fim | wailsapp/wails | go |
<|fim_suffix|>ebviewWindowOptions{
Title: "Wails ML Demo",
Width: 1280,
Height: 1024,
Mac: application.MacWindow{
Backdrop: application.MacBackdropTranslucent,
TitleBar: application.MacTitleBarHiddenInsetUnified,
InvisibleTitleBarHeight: 50,
},
})
app.Event.On("butt... | fim | wailsapp/wails | go |
<|fim_suffix|>ly a http.redirect should be done, but that currently doesn't work on
// WebKit WebViews (macOS/Linux).
// So we handle this as a specific error
return fmt.Errorf("a directory has been requested without a trailing slash, please add a trailing slash to your request")
}
filename = path.Join(fi... | fim | wailsapp/wails | go |
<|fim_prefix|>package assetserver
import (
"fmt"
"net"
"net/http"
"net/url"
"strings"
"time"
)
const (
webViewRequestHeaderWindowId = "x-wails-window-id"
webViewRequestHeaderWindowName = "x-wails-window-name"
HeaderAcceptLanguage = "accept-language"
)
type RuntimeHandler interface {
HandleRunti... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build android
package assetserver
impo<|fim_suffix|>ain configuration
var baseURL = url.URL{
Scheme: "https",
Host: "wails.localhost",
}
<|fim_middle|>rt "net/url"
// Android uses https://wails.localhost as the base URL
// This matches the WebViewAssetLoader dom<|endoftext|> | fim | wailsapp/wails | go |
<|fim_suffix|>corder()
server.ServeHTTP(rr, req)
}
})
b.Run("NoMatch", func(b *testing.B) {
req := httptest.NewRequest("GET", "/static/app.js", nil)
for b.Loop() {
rr := httptest.NewRecorder()
server.ServeHTTP(rr, req)
}
})
}
<|fim_prefix|>//go:build bench
package assetserver
import (
"fmt"
"lo... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build darwin && !ios
package assetserver
import "net/url"
var baseURL = url.URL{
Scheme: "wails",
Ho<|fim_suffix|>}
<|fim_middle|>st: "localhost",
<|endoftext|> | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build !production
package assetserver
import (
"embed"
"io"
iofs "io/fs"
)
//go:embed defaults
var defaultHTML embed.FS
func defaultIndexHTML(language string) []byte {
result := []byte("index.html not found")
// Create an fs<|fim_suffix|>, a.options.Handler != nil,
}
if devServerURL := Get... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:bu<|fim_suffix|>ost: "localhost",
}
<|fim_middle|>ild ios
package assetserver
import "net/url"
var baseURL = url.URL{
Scheme: "wails",
H<|endoftext|> | fim | wailsapp/wails | go |
<|fim_suffix|>ails",
Host: "localhost",
}
<|fim_prefix|>//go:build linux && !android
package assetserver
import <|fim_middle|>"net/url"
var baseURL = url.URL{
Scheme: "w<|endoftext|> | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build production
package assetserver
func defaultIndexHTML(_ string) []byte {
retu<|fim_suffix|> []byte("index.html not found")
}
func (a *AssetServer) LogDetails() {}
<|fim_middle|>rn<|endoftext|> | fim | wailsapp/wails | go |
<|fim_suffix|>tatus), func(t *testing.T) {
res := httptest.NewRecorder()
req, err := http.NewRequest(http.MethodGet, fmt.Sprintf("%s?status=%d", path, status), nil)
if err != nil {
t.Fatal("http.NewRequest failed: ", err)
}
srv.ServeHTTP(res, req)
fallbackTriggered := false
if status... | fim | wailsapp/wails | go |
<|fim_prefix|>package<|fim_suffix|> }
q.Add(in)
for q.Len() != 0 {
out, _ := q.Peek()
select {
case outC <- out:
q.Remove()
case in, ok := <-inC:
if !ok {
return
}
q.Add(in)
}
}
}
}
<|fim_middle|> assetserver
import (
"context"
"fmt"
"net/http"
"net/url"
"strconv"
"st... | fim | wailsapp/wails | go |
<|fim_prefix|>package assetserver<|fim_suffix|>"
var baseURL = url.URL{
Scheme: "http",
Host: "wails.localhost",
}
<|fim_middle|>
import "net/url<|endoftext|> | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build !production
package assetserver
import (
"context"
"io/fs"
"net"
"net/http"
"net/http/httputil"
"net/url"
"os"
"strings"
"time"
)
// retryTransport implements http.RoundTripper with retry logic for transient connection failu<|fim_suffix|>valid FRONTEND_DEVSERVER_URL. Should be valid... | fim | wailsapp/wails | go |
//go:build production
package assetserver
import (
"io/fs"
"net/http"
)
func NewAssetFileServer(vfs fs.FS) http.Handler {
return newAssetFileServerFS(vfs)
}
func GetDevServerURL() string {
return ""
}
<|endoftext|> | fim | wailsapp/wails | go |
<|fim_prefix|>package assetserver
import (
"github.com/wailsapp/wails/v3/internal/assetserver/bundledassets"
"io/fs"
"net/http"
"strings"
)
type BundledAssetServer struct {
handler h<|fim_suffix|>veHTTP(rw, req)
}
<|fim_middle|>ttp.Handler
}
func NewBundledAssetFileServer(fs fs.FS) *BundledAssetServer {
return... | fim | wailsapp/wails | go |
<|fim_prefix|>var sn=Object.defineProperty,Bn=Object.defineProperties;var Nn=Object.getOwnPropertyDescriptors;var rn=Object.getOwnPropertySymbols;var jn=Object.prototype.hasOwnProperty,zn=Object.prototype.propertyIsEnumerable;var an=(n,e,i)=>e in n?sn(n,e,{enumerable:!0,configurable:!0,writable:!0,value:i}):n[e]=i,B=(n... | fim | wailsapp/wails | javascript |
<|fim_prefix|>//go:build !production
package bundle<|fim_suffix|>g.js
var RuntimeJS []byte
<|fim_middle|>dassets
import _ "embed"
//go:embed runtime.debu<|endoftext|> | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build production
package bundledassets
import<|fim_suffix|>untimeJS []byte
<|fim_middle|> _ "embed"
//go:embed runtime.js
var R<|endoftext|> | fim | wailsapp/wails | go |
<|fim_suffix|>args...)
}
}<|fim_prefix|>package assetserver
import (
"context"
"fmt"
"log/slog"
"net/http"
"strings"
)
const (
HeaderHost = "Host"
HeaderContentType = "Content-Type"
HeaderContentLength = "Content-Length"
HeaderUserAgent = "User-Agent"
// TODO: Is this needed?
HeaderCacheCon... | fim | wailsapp/wails | go |
<|fim_suffix|>rw.headerCommitted {
rw.WriteHeader(http.StatusOK)
}
if rw.headerWritten {
return rw.rw.Write(chunk)
}
if len(chunk) == 0 {
return 0, nil
}
// Cut away at most 512 bytes from chunk, and not less than 0.
cut := max(min(len(chunk), 512-len(rw.prefix)), 0)
if cut >= 512 {
// Avoid copying ... | fim | wailsapp/wails | go |
<|fim_suffix|>der != nil {
// Apply headers and forward original map to the main handler.
maps.Copy(fw.rw.Header(), fw.header)
fw.header = fw.rw.Header()
}
fw.rw.WriteHeader(statusCode)
}
// Flush implements the http.Flusher interface.
func (rw *fallbackResponseWriter) Flush() {
if f, ok := rw.rw.(http.Flush... | fim | wailsapp/wails | go |
<|fim_prefix|>package assetserver
import (
"embed"
"errors"
"fmt"
"io/fs"
"os"
"path/filepath"
"strings"
)
// findEmbedRootPath finds the root path in the embed FS. It's the directory which contains all the files.
func findEmbedRootPath(fileSystem embed.FS) (string, error) {
stopErr := errors.New("files or mu... | fim | wailsapp/wails | go |
<|fim_prefix|>package assetserver
import (
"net/http"
)
// Middleware defines a HTTP middleware that can be applied to the AssetServer.
// The handler passed as<|fim_suffix|>leware(middleware ...Middleware) Middleware {
return func(h http.Handler) http.Handler {
for i := len(middleware) - 1; i >= 0; i-- {
h = ... | fim | wailsapp/wails | go |
<|fim_suffix|>e, result)
return result
}<|fim_prefix|>package assetserver
import (
"net/http"
"path/filepath"
"sync"
)
var (
// mimeCache uses sync.Map for better concurrent read performance
// since reads are far more common than writes
mimeCache sync.Map
// mimeTypesByExt maps file extensions to MIME types... | fim | wailsapp/wails | go |
package assetserver
import (
"testing"
)
func TestGetMimetype(t *testing.T) {
type args struct {
filename string
data []byte
}
bomUTF8 := []byte{0xef, 0xbb, 0xbf}
var emptyMsg []byte
css := []byte("body{margin:0;padding:0;background-color:#d579b2}#app{font-family:Avenir,Helvetica,Arial,sans-serif;-webki... | fim | wailsapp/wails | go |
<|fim_suffix|>ta.json", []byte(`{"key": "value"}`), "application/json"},
{"XML file", "data.xml", []byte("<?xml version=\"1.0\"?><root/>"), "text/xml"},
// === IMAGE FORMATS (extension-based) ===
{"PNG file", "image.png", pngData, "image/png"},
{"JPEG file", "photo.jpg", jpegData, "image/jpeg"},
{"JPEG alt e... | fim | wailsapp/wails | go |
<|fim_suffix|> ...Middleware) Middleware
Middleware Middleware
// Logger is the logger used by the AssetServer. If not defined, no logging will be done.
Logger *slog.Logger
}
// Validate the options
func (o Options) Validate() error {
if o.Handler == nil && o.Middleware == nil {
return errors.New("AssetServer o... | fim | wailsapp/wails | go |
<|fim_suffix|>T 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 O... | fim | wailsapp/wails | go |
<|fim_suffix|>rror)
Body() (io.ReadCloser, error)
Response() ResponseWriter
Close() error
}
<|fim_prefix|>package webview
import (
"io"
<|fim_middle|> "net/http"
)
type Request interface {
URL() (string, error)
Method() (string, error)
Header() (http.Header, e<|endoftext|> | fim | wailsapp/wails | go |
<|fim_suffix|>ponseWriter) Write(data []byte) (int, error) {
return w.body.Write(data)
}
func (w *androidResponseWriter) WriteHeader(statusCode int) {
w.statusCode = statusCode
}
func (w *androidResponseWriter) Finish() error {
w.finished = true
return nil
}
// Code returns the HTTP status code of the response
f... | fim | wailsapp/wails | go |
<|fim_suffix|>ody: stream error")
case -2:
return 0, errors.New("body: no stream defined")
case -3:
return 0, io.ErrClosedPipe
default:
return 0, fmt.Errorf("body: unknown error %d", res)
}
}
func (r *requestBodyStreamReader) Close() error {
if r.closed {
return nil
}
r.closed = true
C.URLSchemeTaskRe... | fim | wailsapp/wails | go |
<|fim_prefix|>package webview
import (
"runtime"
"sync/atomic"
)
var _ Request = &requestFinalizer{}
type requestFinalizer struct {
Request
closed int32
}
// newRequestFinalizer returns a request with a runtime finalizer to make sure it will be closed from the finalizer
// if it has not been already clo<|fim_su... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build ios
package webview
/*
#cgo CFLAGS: -x objective-c -fobjc-arc
#cgo LDFLAGS: -framework Foundation -framework WebKit -framework CoreFoundation
#import <Foundation/Foundation.h>
#import <WebKit/WebKit.h>
#import <CoreFoundation/CoreFoundation.h>
#include <string.h>
static void URLSchemeTaskRe... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux && cgo && !gtk3 && !android
package webview
/*
#cgo linux pkg-config: gtk4 webkitgtk-6.0 gio-unix-2.0
#include <gtk/gtk.h>
#include <webkit/webkit.h>
static gboolean unref_request_on_main(gpointer data) {
if (data != NULL) {
g_object_unref(data);
}
return G_SOURCE_REMOVE;
}
// r... | fim | wailsapp/wails | go |
//go:build linux && cgo && gtk3 && !android
package webview
/*
#cgo linux pkg-config: gtk+-3.0 webkit2gtk-4.1 gio-unix-2.0
#include "gtk/gtk.h"
#include "webkit2/webkit2.h"
static gboolean unref_request_on_main(gpointer data) {
if (data != NULL) {
g_object_unref(data);
}
return G_SOURCE_REMOVE;
}
// releaseRe... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux && purego && !android
package webview
import (
"io"
"net/http"
"github.com/ebitengine/purego"
)
// NewRequest creates as new WebViewRequest based on a pointer to an `WebKitURISchemeRequest`
//
// Please make sure to call Release() when finished using the request.
func NewRequest(we... | fim | wailsapp/wails | go |
<|fim_suffix|>y removing the headers that are used in combinationwith caching.
header.Del("If-Modified-Since")
header.Del("If-None-Match")
return header, nil
}
func combineErrs(errs []error) error {
err := errors.Join(errs...)
if err != nil {
// errors.Join wraps even a single error.
// Check the filtered er... | fim | wailsapp/wails | go |
<|fim_prefix|>package webview
import (
"errors"
"net/http"
)
const (
HeaderContentLength = "Content-Length"
HeaderContentType = "Content-Type"
)
var (
errRequestStopped = errors.New("request has been stopped")
errResponseFinished = errors.New("response has been finished")<|fim_suffix|>e
Code() int
}
<|fim... | fim | wailsapp/wails | go |
<|fim_suffix|>afe.Pointer(&headerData[0])
headersLen = len(headerData)
}
C.URLSchemeTaskDidReceiveResponse(rw.r.task, C.int(code), headers, C.int(headersLen))
}
func (rw *responseWriter) Finish() error {
if !rw.wroteHeader {
rw.WriteHeader(http.StatusNotImplemented)
}
if rw.finished {
return nil
}
rw.fi... | fim | wailsapp/wails | go |
<|fim_suffix|>n
}
rw.wroteHeader = true
header := map[string]string{}
for k := range rw.Header() {
header[k] = rw.Header().Get(k)
}
headerData, _ := json.Marshal(header)
// Debug logging for CSS files
if url, err := rw.r.URL(); err == nil && (strings.Contains(url, ".css") || strings.Contains(url, "style")) ... | fim | wailsapp/wails | go |
<|fim_suffix|>*os.File, err error) {
var p [2]int
e := syscall.Pipe2(p[0:], 0)
if e != nil {
return 0, nil, fmt.Errorf("pipe2: %s", e)
}
return p[0], os.NewFile(uintptr(p[1]), "|1"), nil
}
<|fim_prefix|>//go:build linux && cgo && !gtk3 && !android
package we<|fim_middle|>bview
/*
#cgo linux pkg-config: gtk4 w... | fim | wailsapp/wails | go |
<|fim_suffix|>C.int(rFD), C.gboolean(1))
defer C.g_object_unref(C.gpointer(stream))
if err := webkit_uri_scheme_request_finish(rw.req, code, rw.Header(), stream, contentLength); err != nil {
rw.finishWithError(http.StatusInternalServerError, fmt.Errorf("unable to finish request: %s", err))
return
}
}
func (rw ... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux && purego && !android
package webview
import (
"fmt"
"io"
"net/http"
"os"
"strconv"
"syscall"
"github.com/ebitengine/purego"
)
const (
gtk3 = "libgtk-3.so"
gtk4 = "libgtk-4.so"
)
var (
gtk uintptr
webkit uintptr
version int
)
func init() {
var err error
// gtk, er... | fim | wailsapp/wails | go |
<|fim_suffix|>l
}
rw.finished = true
var errs []error
code := rw.code
if code == http.StatusNotModified {
// WebView2 has problems when a request returns a 304 status code and the WebView2 is going to hang for other
// requests including IPC calls.
errs = append(errs, errors.New("AssetServer returned 304 -... | fim | wailsapp/wails | go |
<|fim_suffix|>entLen = len(p)
}
var n C.gsize
var gErr *C.GError
res := C.g_input_stream_read_all(r.stream, content, C.gsize(contentLen), &n, nil, &gErr)
if res == 0 {
return 0, formatGError("stream read failed", gErr)
} else if n == 0 {
return 0, io.EOF
}
return int(n), nil
}
func (r *webkitRequestBody) ... | fim | wailsapp/wails | go |
<|fim_suffix|><libsoup/soup.h>
*/
import "C"
import (
"fmt"
"io"
"net/http"
"strings"
"unsafe"
)
const Webkit2MinMinorVersion = 0
func webkit_uri_scheme_request_get_http_method(req *C.WebKitURISchemeRequest) string {
method := C.GoString(C.webkit_uri_scheme_request_get_http_method(req))
return strings.ToUpper... | fim | wailsapp/wails | go |
<|fim_suffix|>ast reference is dropped, but you might want to call this function
// to make sure resources are released as early as possible.
var err error
var gErr *C.GError
if C.g_input_stream_close(r.stream, nil, &gErr) == 0 {
err = formatGError("stream close failed", gErr)
}
C.g_object_unref(C.gpointer(r.st... | fim | wailsapp/wails | go |
<|fim_suffix|>return open(url)
}
// OpenFile opens the named file in the default browser or file handler.
func OpenFile(path string) error {
return open(path)
}
<|fim_prefix|>// Package browser provides functions to open URLs and files in the default b<|fim_middle|>rowser.
package browser
// OpenURL opens the named ... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build darwin
package browser
imp<|fim_suffix|> return err
}
go cmd.Wait() //nolint:errcheck
return nil
}
<|fim_middle|>ort "os/exec"
var openCmd = func(target string) *exec.Cmd {
return exec.Command("open", target)
}
func open(target string) error {
cmd := openCmd(target)
if err := cmd.Star... | fim | wailsapp/wails | go |
<|fim_suffix|> := os.WriteFile(path, []byte("hello"), 0644); err != nil {
t.Fatalf("failed to create temp file: %v", err)
}
if err := OpenFile(path); err != nil {
t.Errorf("OpenFile returned unexpected error: %v", err)
}
}
<|fim_prefix|>//go:build integration
package browser
import (
"os"
"path/filepath"
"t... | fim | wailsapp/wails | go |
<|fim_suffix|>ror {
cmd := openCmd(target)
if err := cmd.Start(); err != nil {
return err
}
go cmd.Wait() //nolint:errcheck
return nil
}
<|fim_prefix|>//go:build !darwin && !windows
package browser
import "os/exec"
var openCmd = func(target string) *exec.Cmd {
return exe<|fim_middle|>c.Command("xdg-open", ta... | fim | wailsapp/wails | go |
<|fim_prefix|>package browser
import (
"os"
"os/exec"
"testing"
)
// TestOpen_Success covers the happy path via a stub that r<|fim_suffix|>ample.com"); err != nil {
t.Errorf("OpenURL unexpected error: %v", err)
}
if err := OpenFile("some/file"); err != nil {
t.Errorf("OpenFile unexpected error: %v", err)
}
... | fim | wailsapp/wails | go |
<|fim_suffix|>= openCmd(target)
if err := cmd.Start(); err != nil {
return err
}
go cmd.Wait() //nolint:errcheck
return nil
}
<|fim_prefix|>//go:build windows
package browser
import "os/exec"
v<|fim_middle|>ar openCmd = func(target string) *exec.Cmd {
return exec.Command("rundll32", "url.dll,FileProtocolHandl... | fim | wailsapp/wails | go |
<|fim_suffix|>he Wails source tree is nowhere on their machine.
// The downstream effect was a malformed `replace github.com/wailsapp/wails/v3
// => /v3` directive in scaffolded projects, breaking `wails3 init`
// outright.
//
// [wdebug.LocalModulePath] is set by the debug package's init() only
// when `.git` is... | fim | wailsapp/wails | go |
<|fim_suffix|>LocalModulePath
t.Cleanup(func() { wdebug.LocalModulePath = saved })
wdebug.LocalModulePath = ""
info, err := Get()
if err != nil {
t.Fatalf("buildinfo.Get() returned error: %v", err)
}
if info.Development {
t.Fatalf("Development = true with empty LocalModulePath; want false (this is the relea... | fim | wailsapp/wails | go |
<|fim_prefix|>package capabilities
import "encoding/json"
type Capabilities struct {
HasNativeDrag bool `json:"HasNativeDra<|fim_suffix|>son:"WebKitVersion"`
}
func (c Capabilities) AsBytes() []byte {
// JSON encode
result, err := json.Marshal(c)
if err != nil {
return []byte("{}")
}
return result
}
<|fim_... | fim | wailsapp/wails | go |
<|fim_suffix|>wCapabilities(_ string) Capabilities {
c := Capabilities{}
c.HasNativeDrag = false
return c
}
<|fim_prefix|>//go:build <|fim_middle|>darwin
package capabilities
func ne<|endoftext|> | fim | wailsapp/wails | go |
<|fim_suffix|>,
}
}
<|fim_prefix|>//go:build linux && !gtk3
package capab<|fim_middle|>ilities
func NewCapabilities() Capabilities {
return Capabilities{
HasNativeDrag: true,
GTKVersion: 4,
WebKitVersion: "6.0"<|endoftext|> | fim | wailsapp/wails | go |
<|fim_prefix|>//go:bui<|fim_suffix|>kage capabilities
func NewCapabilities() Capabilities {
return Capabilities{
HasNativeDrag: true,
GTKVersion: 3,
WebKitVersion: "4.1",
}
}
<|fim_middle|>ld linux && gtk3
pac<|endoftext|> | fim | wailsapp/wails | go |
//go:build windows
package capabilities
import "github.com/wailsapp/wails/webview2/webviewloader"
type version string
func (v version) IsAtLeast(input string) bool {
result, err := webviewloader.CompareBrowserVersions(string(v), input)
if err != nil {
return false
}
return result >= 0
}
func NewCapabilities(... | fim | wailsapp/wails | go |
<|fim_prefix|>package changelog
import (
"fmt"
"io"
"os"
"strings"
)
// ProcessorResult contains the results of processing a changelog file
type ProcessorResult struct {
Entry *ChangelogEntry
ValidationResult ValidationResult
HasContent bool
}
// Processor handles the complete changelog proce... | fim | wailsapp/wails | go |
<|fim_prefix|>package changelog
import (
"os"
"path/filepath"
"strings"
"testing"
)
func TestNewProcessor(t *testing.T) {
processor := NewProcessor()
if processor == nil {
t.Fatal("NewProcessor() returned nil")
}
if processor.parser == nil {
t.Error("parser not initialized")
}
if processor.validator == ... | fim | wailsapp/wails | go |
<|fim_prefix|>package changelog
import (
"bufio"
"fmt"
"io"
"regexp"
"strings"
"time"
)
// ChangelogEntry represents a parsed changelog entry following Keep a Changelog format
type ChangelogEntry struct {
Version string `json:"version"`
Date time.Time `json:"date"`
Added []string `json:"add... | fim | wailsapp/wails | go |
<|fim_suffix|> "Another with extra spaces",
}
if len(entry.Fixed) != len(expectedFixed) {
t.Errorf("Expected %d Fixed items, got %d", len(expectedFixed), len(entry.Fixed))
}
for i, expected := range expectedFixed {
if i >= len(entry.Fixed) || entry.Fixed[i] != expected {
t.Errorf("Expected Fixed[%d] to be ... | fim | wailsapp/wails | go |
<|fim_suffix|>erns like horizontal rules or section comments
if !strings.HasPrefix(trimmedLine, "---") &&
!strings.HasPrefix(trimmedLine, "###") &&
!strings.HasPrefix(trimmedLine, "**") {
result.Valid = false
result.Errors = append(result.Errors, ValidationError{
Field: "content",
Message... | fim | wailsapp/wails | go |
<|fim_prefix|>package changelog
import (
"strings"
"testing"
)
func TestNewValidator(t *testing.T) {
validator := NewValidator()
if validator == nil {
t.Fatal("NewValidator() returned nil")
}
if validator.sectionHeaderRegex == nil {
t.Error("sectionHeaderRegex not initialized")
}
if validator.bulletPointR... | fim | wailsapp/wails | go |
<|fim_suffix|>ch))
// Quote the executable and --appdir args so `s.EXEC`'s shlex split
// keeps them as single tokens when the user-supplied paths contain
// spaces.
cmd := fmt.Sprintf("%q --appimage-extract-and-run --appdir %q --output appimage --plugin gtk", linuxdeployAppImage, appDir)
s.SETENV("DEPLOY_GTK_VER... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build full_test
package commands_test
import (
"github.com/wailsapp/wails/v3/internal/commands"
"github.com/wailsapp/wails/v3/internal/s"
"testing"
)
func Test_generateAppImage(t *testing.T) {
tests := []struct {
name string
options *commands.GenerateAppImageOptions
wantErr bool
... | fim | wailsapp/wails | go |
<|fim_prefix|>package main
import (
"fmt"
"log"
"math/rand"
"runtime"
"strconv"
"time"
"github.com/wailsapp/wails/v3/internal/lo"
"github.com/wailsapp/wails/v3/pkg/events"
"github.com/wailsapp/wails/v3/pkg/application"
)
func main() {
app := application.New(application.Options{
Name: "WebviewWind... | fim | wailsapp/wails | go |
<|fim_prefix|>package commands
import (
"errors"
"fmt"
"os"
"path/filepath"
"github.com/wailsapp/wails/v3/internal/flags"
"github.com/wailsapp/wails/v3/internal/generator"
"github.com/wailsapp/wails/v3/internal/generator/config"
"github.com/wailsapp/wails/v3/internal/term"
)
func GenerateBindings(options *fl... | fim | wailsapp/wails | go |
<|fim_prefix|>package commands
import (
"bytes"
"errors"
"io/fs"
"os"
"path/filepath"
"runtime"
"time"
)
// syncDirs makes dst's contents identical to src's, then removes src.
//
// Unlike a RemoveAll+Rename swap, dst itself is never deleted or renamed:
// on Windows a file watcher (e.g. Vite's chokidar) holds... | fim | wailsapp/wails | go |
<|fim_suffix|>iteFiles(t, dst, map[string]string{
"thing/nested": "was a dir",
"other": "was a file",
})
if err := syncDirs(src, dst); err != nil {
t.Fatal(err)
}
checkTree(t, dst, map[string]string{
"thing": "now a file",
"other/x": "in dir",
"plain.ts": "p",
})
}
func TestSyncDirsDestina... | fim | wailsapp/wails | go |
<|fim_prefix|>package commands
import (
"embed"
"fmt"
"io/fs"
"os"
"path/filepath"
"runtime"
"strings"
"time"
"github.com/wailsapp/wails/v3/internal/gosod"
"gopkg.in/yaml.v3"
"howett.net/plist"
)
//go:embed build_assets
var buildAssets embed.FS
//go:embed updatable_build_assets
var updatableBuildAssets ... | fim | wailsapp/wails | go |
<|fim_prefix|>package commands
import (
"os"
"path/filepath"
"reflect"
"strings"
"testing"
"gopkg.in/yaml.v3"
"howett.net/plist"
)
func TestGenerateBuildAssets(t *testing.T) {
// Create a temporary directory for testing
tempDir, err := os.MkdirTemp("", "wails-build-assets-test-*")
if err<|fim_suffix|>nfig ... | fim | wailsapp/wails | go |
<|fim_prefix|>package com.wails.app;
import android.annotation.SuppressLint;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.res.Configuration;
import android.database.Cursor;
import android.net.Connect... | fim | wailsapp/wails | java |
<|fim_prefix|>package com.wails.app;
import android.app.Activity;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.content.ClipData;
import android.content.ClipboardManager;
import android.content.Context;
import android.content.Intent;
imp... | fim | wailsapp/wails | java |
package com.wails.app;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Intent;
import android.content.pm.ServiceInfo;
import android.os.Build;
import android.os.IBinder;
import androidx.annotation... | fim | wailsapp/wails | java |
package com.wails.app;
import android.util.Log;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import android.webkit.JavascriptInterface;
import android.webkit.WebView;
import com.wails.app.BuildConfig;
/**
* WailsJSBridge provides the JavaScript interface that allows the web fro... | fim | wailsapp/wails | java |
<|fim_prefix|>package com.wails.app;
import android.net.Uri;
import android.util.Log;
import android.webkit.WebResourceResponse;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.webkit.WebViewAssetLoader;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import ... | fim | wailsapp/wails | java |
<|fim_prefix|>//go:build android
package main
import "github.com/wailsapp/wails/v3/pkg/application"
func init() {
// Register main function to be called when the Android ap<|fim_suffix|>d
application.RegisterAndroidMain(main)
}
<|fim_middle|>p initializes
// This is necessary because in c-shared build mode, main(... | fim | wailsapp/wails | go |
<|fim_prefix|>package main
import (
"fmt"
"os"
"os/exec"
"path/filepath"
"runtime"
"strings"
)
func main() {
fmt.Println("Checking Android development dependencies...")
fmt.Println()
errors := []string{}
// Check Go
if !checkCommand("go", "version") {
errors = append<|fim_suffix|> "ndk")
if entries, ... | fim | wailsapp/wails | go |
<|fim_suffix|>*application.Options) {
// No modifications needed for non-iOS platforms
}<|fim_prefix|>//go:build !ios
package main
import "github.com/wailsapp/wails/v3/pkg/applicati<|fim_middle|>on"
// modifyOptionsForIOS is a no-op on non-iOS platforms
func modifyOptionsForIOS(opts <|endoftext|> | fim | wailsapp/wails | go |
<|fim_suffix|>
// modifyOptionsForIOS adjusts the application options for iOS
func modifyOptionsForIOS(opts *application.Options) {
// Disable signal handlers on iOS to prevent crashes
opts.DisableDefaultSignalHandler = true
}<|fim_prefix|>//go:build ios
package main
import "github.com/wailsapp/wails/v<|fim_middle... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build ios
package main
import (
"C"
)
// For iOS builds, we need to export a function that can be called <|fim_suffix|>eived on thread with no signal stack"
// "fatal error: non-Go code disabled sigaltstack"
// iOS apps run in a sandboxed environment where the Go runtime's
// signal handling d... | fim | wailsapp/wails | go |
<|fim_prefix|>// install_deps.go - iOS development dependency checker
// This script checks for required iOS development tools.
// It's designed to be portable across different shells by using Go instead of shell scripts.
//
// Usage:
// go run install_deps.go # Interactive mode
// TASK_FORCE_Y... | fim | wailsapp/wails | go |
<|fim_suffix|> true,
}
GenerateBuildAssets(options)
expected := archToMSIX(runtime.GOARCH)
if options.ProcessorArchitecture != expected {
t.Errorf("ProcessorArchitecture = %q, want %q (from runtime.GOARCH=%q)", options.ProcessorArchitecture, expected, runtime.GOARCH)
}
}
<|fim_prefix|>package command... | fim | wailsapp/wails | go |
<|fim_suffix|>(`,"linux":{"gtk4_available":%t,"gtk3_available":%t,"webkitgtk_6_available":%t,"webkit2gtk_4_1_available":%t,"recommended":"%s"}`,
l.GTK4Available, l.GTK3Available, l.WebKitGTK6Available, l.WebKit2GTK4Available, l.Recommended)
}
result += "}"
return result
}
<|fim_prefix|>package commands
import (
... | fim | wailsapp/wails | go |
<|fim_prefix|>package commands
import (
"os"
"github.com/wailsapp/wails/v3/internal/generator"
)
type Gene<|fim_suffix|> DisableFooter = true
goData, err := os.ReadFile(options.ConstantsFilename)
if err != nil {
return err
}
result, err := generator.GenerateConstants(goData)
if err != nil {
return err
}... | fim | wailsapp/wails | go |
package commands
import (
"os"
"path/filepath"
"strings"
"testing"
)
func TestDarwinMinimumVersionInTemplates(t *testing.T) {
tempDir, err := os.MkdirTemp("", "wails-darwin-version-test-*")
if err != nil {
t.Fatalf("Failed to create temp directory: %v", err)
}
defer os.RemoveAll(tempDir)
options := &Build... | fim | wailsapp/wails | go |
<|fim_suffix|>t.Sprintf("https://%s:%d", host, port))
} else {
os.Setenv("FRONTEND_DEVSERVER_URL", fmt.Sprintf("http://%s:%d", host, port))
}
return Watcher(&WatcherOptions{
Config: options.Config,
})
}
<|fim_prefix|>package commands
import (
"fmt"
"net"
"os"
"strconv"
"github.com/wailsapp/wails/v3/inte... | fim | wailsapp/wails | go |
<|fim_suffix|> hdiutil
if err := c.createDMGWithHdiutil(tempDir); err != nil {
return fmt.Errorf("failed to create DMG with hdiutil: %w", err)
}
return nil
}
// copyDir recursively copies a directory
func (c *Creator) copyDir(src, dst string) error {
cmd := exec.Command("cp", "-R", src, dst)
if err := cmd.Run(... | fim | wailsapp/wails | go |
<|fim_suffix|>uct{}
func Doctor(_ *DoctorOptions) error {
return doctor.Run()
}
<|fim_prefix|>package commands
import (
"githu<|fim_middle|>b.com/wailsapp/wails/v3/internal/doctor"
)
type DoctorOptions str<|endoftext|> | fim | wailsapp/wails | go |
<|fim_prefix|>package commands
import (
"github.com/wailsapp/wails/v3/pkg/<|fim_suffix|>eractive()
}
return tui.RunSimple()
}
<|fim_middle|>doctor-ng/tui"
)
type DoctorNgOptions struct {
NonInteractive bool `name:"n" description:"Run in non-interactive mode (no TUI)"`
}
func DoctorNg(options *DoctorNgOptions) e... | fim | wailsapp/wails | go |
<|fim_prefix|>package commands
import (
"bytes"
"fmt"
"os"
)
type DotDesktopOptions struct {
OutputFile string `description:"The output file to write to"`
Type string `description:"The type of the desktop entry" default:"Application"`
Name string `description:"The name of the application"`
... | fim | wailsapp/wails | go |
<|fim_suffix|>dFile(expectedFile)
if err != nil {
t.Fatalf("Failed to read output file: %v", err)
}
if !strings.Contains(string(content), "Name=My App") {
t.Errorf("Expected 'Name=My App' in .desktop file (name should NOT be normalised), got:\n%s", string(content))
}
}
func TestGenerateDotDesktopErrors(t *tes... | fim | wailsapp/wails | go |
<|fim_suffix|>!= nil {
return fmt.Errorf("failed to write entitlements file: %w", err)
}
pterm.Success.Printfln("Wrote %s", path)
// Show summary
pterm.Info.Println("Entitlements:")
for _, key := range entitlements {
for _, e := range availableEntitlements {
if e.Key == key {
fmt.Printf(" - %s\n", e.... | fim | wailsapp/wails | go |
<|fim_prefix|>package commands
import (
<|fim_suffix|>teTemplate(options *templates.BaseTemplate) error {
return templates.GenerateTemplate(options)
}
<|fim_middle|> "github.com/wailsapp/wails/v3/internal/templates"
)
func Genera<|endoftext|> | fim | wailsapp/wails | go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.