Added plugin reload

plugins_test.go

@@ -281,7 +281,10 @@ func TestApp_PluginIntegration(t *testing.T) {
 	writePluginFile(t, dir, "upper.ucl", `d:filter "String: To Upper Case" { |in| strs:to-upper $in }`)
 	writePluginFile(t, dir, "rev.ucl", `d:filter "Custom: Echo" { |in| $in }`)
 
-	app.plugins.LoadDir(ctx, app.uclInst, dir)
+	if n := app.loadPluginsFrom(dir); n != 2 {
+		t.Fatalf("expected 2 filters loaded, got %d", n)
+	}
+	_ = ctx
 
 	t.Run("ListProcessors shadows built-in by label", func(t *testing.T) {
 		resp := app.ListProcessors()
@@ -318,3 +321,92 @@ func TestApp_PluginIntegration(t *testing.T) {
 		}
 	})
 }
+
+func TestApp_ReloadPlugins(t *testing.T) {
+	ctx := context.Background()
+	app := NewApp(nil)
+	dir := t.TempDir()
+
+	writePluginFile(t, dir, "a.ucl", `
+proc helper { |s| strs:to-upper $s }
+d:filter "Filter A" { |in| helper $in }
+`)
+
+	if n := app.loadPluginsFrom(dir); n != 1 {
+		t.Fatalf("expected 1 filter, got %d", n)
+	}
+
+	firstInst, firstPlugins, firstCtx := app.current()
+	if uclInstFromContext(firstCtx) != firstInst {
+		t.Fatal("context does not carry the current interpreter")
+	}
+	if res, err := firstInst.EvalString(ctx, `helper "x"`); err != nil || res != "X" {
+		t.Fatalf("helper proc should be defined: %v %v", res, err)
+	}
+	filterA, ok := firstPlugins.filters["plugin:filter-a"]
+	if !ok {
+		t.Fatal("Filter A not registered")
+	}
+
+	// Replace a.ucl with b.ucl and reload.
+	if err := os.Remove(filepath.Join(dir, "a.ucl")); err != nil {
+		t.Fatal(err)
+	}
+	writePluginFile(t, dir, "b.ucl", `d:filter "Filter B" { |in| strs:to-lower $in }`)
+
+	if n := app.loadPluginsFrom(dir); n != 1 {
+		t.Fatalf("expected 1 filter after reload, got %d", n)
+	}
+
+	secondInst, secondPlugins, secondCtx := app.current()
+	if secondInst == firstInst {
+		t.Error("interpreter should have been rebuilt")
+	}
+	if uclInstFromContext(secondCtx) != secondInst {
+		t.Error("context should carry the new interpreter")
+	}
+	if _, ok := secondPlugins.filters["plugin:filter-a"]; ok {
+		t.Error("Filter A should have been deregistered")
+	}
+	if _, ok := app.lookupProcessor("plugin:filter-a"); ok {
+		t.Error("lookupProcessor should no longer find Filter A")
+	}
+	if proc, ok := app.lookupProcessor("plugin:filter-b"); !ok || proc.Label != "Filter B" {
+		t.Errorf("Filter B should be registered, got %v %v", proc, ok)
+	}
+	if _, err := secondInst.EvalString(ctx, `helper "x"`); err == nil {
+		t.Error("helper proc from the removed file should no longer be defined")
+	}
+
+	t.Run("filter captured before reload still works", func(t *testing.T) {
+		res, err := filterA.Filter(ctx, "abc")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if res.Output != "ABC" {
+			t.Errorf("output = %q", res.Output)
+		}
+	})
+
+	t.Run("reload with bad file reports fresh errors", func(t *testing.T) {
+		writePluginFile(t, dir, "c.ucl", `d:filter "Broken" { |in|`)
+
+		n := app.loadPluginsFrom(dir)
+
+		_, plugins, _ := app.current()
+		if n != 1 || len(plugins.filters) != 1 {
+			t.Errorf("expected only Filter B to survive, got n=%d filters=%v", n, plugins.filters)
+		}
+		if errs := plugins.Errors(); len(errs) != 1 || !strings.Contains(errs[0].Error(), "c.ucl") {
+			t.Errorf("expected one error naming c.ucl, got %v", errs)
+		}
+
+		if err := os.Remove(filepath.Join(dir, "c.ucl")); err != nil {
+			t.Fatal(err)
+		}
+		app.loadPluginsFrom(dir)
+		if _, plugins, _ := app.current(); len(plugins.Errors()) != 0 {
+			t.Errorf("errors should be cleared after a clean reload, got %v", plugins.Errors())
+		}
+	})
+}