various fixes

Author: dunglas

internal/watcher/cgo.go

@@ -2,6 +2,7 @@
 
 package watcher
 
+// #cgo LDFLAGS: -lwatcher-c -lstdc++
 // #include <stdint.h>
 // #include <stdlib.h>
 // #include "watcher.h"
@@ -21,47 +22,47 @@ type patternGroup struct {
 	callback callbackFunc
 }
 
-type watcher struct {
-	patternGroup   *patternGroup
-	name           string
-	parsedPatterns []string
-	events         chan eventHolder
-	failureCount   int
-	watcher        C.uintptr_t
+type pattern struct {
+	patternGroup *patternGroup
+	value        string
+	parsedValues []string
+	events       chan eventHolder
+	failureCount int
+	watcher      C.uintptr_t
 }
 
-func (p *watcher) startSession() error {
+func (p *pattern) startSession() error {
 	handle := cgo.NewHandle(p)
-	cDir := C.CString(p.name)
+	cDir := C.CString(p.value)
 	defer C.free(unsafe.Pointer(cDir))
 
 	p.watcher = C.start_new_watcher(cDir, C.uintptr_t(handle))
 	if p.watcher != 0 {
 		if globalLogger.Enabled(globalCtx, slog.LevelDebug) {
-			globalLogger.LogAttrs(globalCtx, slog.LevelDebug, "watching", slog.String("watcher", p.name), slog.Any("groups", p.parsedPatterns))
+			globalLogger.LogAttrs(globalCtx, slog.LevelDebug, "watching", slog.String("pattern", p.value))
 		}
 
 		return nil
 	}
 
 	if globalLogger.Enabled(globalCtx, slog.LevelError) {
-		globalLogger.LogAttrs(globalCtx, slog.LevelError, "couldn't start watching", slog.String("watcher", p.name))
+		globalLogger.LogAttrs(globalCtx, slog.LevelError, "couldn't start watching", slog.String("pattern", p.value))
 	}
 
 	return ErrUnableToStartWatching
 }
 
-// this method prepares the watcher struct (aka /name/*watcher)
-func (p *watcher) parse() error {
-	// first we clean the name
-	absPattern, err := fastabs.FastAbs(p.name)
+// this method prepares the pattern struct (aka /path/*pattern)
+func (p *pattern) parse() error {
+	// first we clean the value
+	absPattern, err := fastabs.FastAbs(p.value)
 	if err != nil {
 		return err
 	}
 
-	p.name = absPattern
+	p.value = absPattern
 
-	// then we split the name to determine where the directory ends and the name starts
+	// then we split the value to determine where the directory ends and the value starts
 	splitPattern := strings.Split(absPattern, string(filepath.Separator))
 	patternWithoutDir := ""
 	for i, part := range splitPattern {
@@ -70,33 +71,33 @@ func (p *watcher) parse() error {
 
 		if isFilename || isGlobCharacter {
 			patternWithoutDir = filepath.Join(splitPattern[i:]...)
-			p.name = filepath.Join(splitPattern[:i]...)
+			p.value = filepath.Join(splitPattern[:i]...)
 
 			break
 		}
 	}
 
-	// now we split the name according to the recursive '**' syntax
-	p.parsedPatterns = strings.Split(patternWithoutDir, "**")
-	for i, pp := range p.parsedPatterns {
-		p.parsedPatterns[i] = strings.Trim(pp, string(filepath.Separator))
+	// now we split the value according to the recursive '**' syntax
+	p.parsedValues = strings.Split(patternWithoutDir, "**")
+	for i, pp := range p.parsedValues {
+		p.parsedValues[i] = strings.Trim(pp, string(filepath.Separator))
 	}
 
 	// finally, we remove the trailing separator and add leading separator
-	p.name = string(filepath.Separator) + strings.Trim(p.name, string(filepath.Separator))
+	p.value = string(filepath.Separator) + strings.Trim(p.value, string(filepath.Separator))
 
 	return nil
 }
 
-func (p *watcher) allowReload(event *Event) bool {
+func (p *pattern) allowReload(event *Event) bool {
 	if !isValidEventType(event.EffectType) || !isValidPathType(event) {
 		return false
 	}
 
-	return isValidPattern(event, p.name, p.parsedPatterns)
+	return isValidPattern(event, p.value, p.parsedValues)
 }
 
-func (p *watcher) handle(event *Event) {
+func (p *pattern) handle(event *Event) {
 	// If the globalWatcher prematurely sends the die@ event, retry watching
 	if event.PathType == PathTypeWatcher && strings.HasPrefix(event.PathName, "e/self/die@") && watcherIsActive.Load() {
 		p.retryWatching()
@@ -109,9 +110,9 @@ func (p *watcher) handle(event *Event) {
 	}
 }
 
-func (p *watcher) stop() {
+func (p *pattern) stop() {
 	if C.stop_watcher(p.watcher) == 0 && globalLogger.Enabled(globalCtx, slog.LevelWarn) {
-		globalLogger.LogAttrs(globalCtx, slog.LevelWarn, "couldn't close the globalWatcher")
+		globalLogger.LogAttrs(globalCtx, slog.LevelWarn, "couldn't close the watcher")
 	}
 }
 
@@ -121,30 +122,30 @@ func isValidEventType(effectType EffectType) bool {
 
 func isValidPathType(event *Event) bool {
 	if event.PathType == PathTypeWatcher && globalLogger.Enabled(globalCtx, slog.LevelDebug) {
-		globalLogger.LogAttrs(globalCtx, slog.LevelDebug, "special edant/globalWatcher event", slog.Any("event", event))
+		globalLogger.LogAttrs(globalCtx, slog.LevelDebug, "special e-dant/watcher event", slog.Any("event", event))
 	}
 
 	return event.PathType <= PathTypeHardLink
 }
 
 // some editors create temporary files and never actually modify the original file
-// so we need to also check the associated watcher of an event
+// so we need to also check Event.AssociatedPathName
 // see https://github.com/php/frankenphp/issues/1375
 func isValidPattern(event *Event, dir string, patterns []string) bool {
 	fileName := event.AssociatedPathName
 	if fileName == "" {
 		fileName = event.PathName
 	}
 
-	// first we remove the name from the name
+	// first we remove the value from the value
 	if !strings.HasPrefix(fileName, dir) {
 		return false
 	}
 
-	// remove the name and separator from the filename
+	// remove the value and separator from the filename
 	fileNameWithoutDir := strings.TrimPrefix(strings.TrimPrefix(fileName, dir), string(filepath.Separator))
 
-	// if the name has size 1 we can match it directly against the filename
+	// if the value has size 1 we can match it directly against the filename
 	if len(patterns) == 1 {
 		return matchBracketPattern(patterns[0], fileNameWithoutDir)
 	}
@@ -156,16 +157,16 @@ func matchPatterns(patterns []string, fileName string) bool {
 	partsToMatch := strings.Split(fileName, string(filepath.Separator))
 	cursor := 0
 
-	// if there are multiple parsedPatterns due to '**' we need to match them individually
+	// if there are multiple parsedValues due to '**' we need to match them individually
 	for i, pattern := range patterns {
 		patternSize := strings.Count(pattern, string(filepath.Separator)) + 1
 
-		// if we are at the last name we will start matching from the end of the filename
+		// if we are at the last value we will start matching from the end of the filename
 		if i == len(patterns)-1 {
 			cursor = len(partsToMatch) - patternSize
 		}
 
-		// the cursor will move through the fileName until the name matches
+		// the cursor will move through the fileName until the value matches
 		for j := cursor; j < len(partsToMatch); j++ {
 			cursor = j
 			subPattern := strings.Join(partsToMatch[j:j+patternSize], string(filepath.Separator))
@@ -185,7 +186,7 @@ func matchPatterns(patterns []string, fileName string) bool {
 	return true
 }
 
-// we also check for the following bracket syntax: /name/*.{php,twig,yaml}
+// we also check for the following bracket syntax: /value/*.{php,twig,yaml}
 func matchBracketPattern(pattern string, fileName string) bool {
 	openingBracket := strings.Index(pattern, "{")
 	closingBracket := strings.Index(pattern, "}")
@@ -230,14 +231,14 @@ func matchPattern(pattern string, fileName string) bool {
 
 //export go_handle_file_watcher_event
 func go_handle_file_watcher_event(event C.struct_wtr_watcher_event, handle C.uintptr_t) {
-	p := cgo.Handle(handle).Value().(*watcher)
+	p := cgo.Handle(handle).Value().(*pattern)
 
 	e := &Event{
 		time.Unix(int64(event.effect_time)/1000000000, int64(event.effect_time)%1000000000),
 		C.GoString(event.path_name),
 		C.GoString(event.associated_path_name),
-		EffectType(event.path_type),
-		PathType(event.effect_type),
+		EffectType(event.effect_type),
+		PathType(event.path_type),
 	}
 
 	p.handle(e)