gui: say where the files go, and let a declaration describe itself

Three fixes, all of them from the owner looking at the screen rather than from
a guard. That step has now found something every time it has been taken.

The output directory is written out in full instead of as a dot, with a Choose
button beside it. A dot is clear in a terminal, where you walked into the
directory yourself. Started from a desktop it means somewhere, and this is the
one part of the tool that writes into other people's directories. The box stays
a box, so a path somebody sent you can still be pasted in.

A text setting can say what sort of text it takes. "text" under a field is a
word where a description should be, and the declaration for the spread of a
boundary set already knew it wanted a list of sizes with nowhere to put it. The
guard for that found two more the same way, in zip and targz.

What a preset typically finds is a list of lines. Run together it read as three
times as many findings as there are, because the entries have commas in them.

The picker cost one module and which one is the point. fyne.io/fyne/v2/dialog
imports github.com/FyshOS/fancyfs, which was already named in our module graph
because the toolkit requires it - importing dialog moved it from named to
downloaded, checksummed and compiled in. Checked before accepting: BSD-3, one
way compatible with GPL-3.0 like the eleven other BSD-3 modules here, 129 lines,
written by the author of the toolkit itself, and reached from a single line
where it decorates folder icons. Tidying afterwards pruned kr/text, which took
creack/pty out of the graph, so the dependency gate went from 69 modules to 68
and its expected list was changed deliberately rather than to make it pass.

That import also showed a hole in the notices guard. It asked whether every
listed module is still built and never the other way round, so a module that
ARRIVED went unlisted - which is the direction the licences care about, since
they require the notice to travel with the code that ships. It asks both now.
Its first run raised two false alarms worth recording: goccy/go-yaml and x/text
are noticed under their own headings with the whole licence text rather than as
table rows, which is a stronger notice and not a weaker one.

Host gained ChooseDirectory and it always calls back, including with nothing
when somebody cancels. A host that stays silent on cancel leaves the caller's
handling of that answer unreachable from any test, which is how the mutation for
it first came back NOT CAUGHT.

Guards 247 to 252, mutations 229 to 235.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: donislawdev

.github/workflows/ci.yml

@@ -61,11 +61,21 @@ jobs:
         # to be visible rather than discovered later.
         #
         # Two questions rather than one, since the graphics toolkit arrived
-        # on 2026-08-05. The graph below is 69 modules and most of them are
+        # on 2026-08-05. The graph below is 68 modules and most of them are
         # Fyne's. Their licences were measured before it was added and every
         # one in the linked set is permissive and one way compatible with
         # GPL-3.0: 13 BSD-3, 10 MIT, 1 Apache-2.0, 1 BSD-2, 1 ISC.
         #
+        # Changed once since, on 2026-08-05, when the window gained a
+        # folder picker. github.com/FyshOS/fancyfs was already named here
+        # because the toolkit requires it - importing the dialog package
+        # moved it from named to downloaded, checksummed and compiled in.
+        # Checked before it was accepted: BSD-3, 129 lines, written by the
+        # toolkit's own author, and reached from one line of the dialog
+        # package where it decorates folder icons. Tidying after it pruned
+        # github.com/kr/text from go.mod, which took github.com/creack/pty
+        # out of the graph, taking the count from 69 to 68.
+        #
         # The second question protects what ships to most people. The
         # command line binary links exactly two external modules and the
         # toolkit is not among them, so a build for a server carries no
@@ -86,7 +96,6 @@ jobs:
             github.com/anthonynsimon/bild \
             github.com/clipperhouse/uax29/v2 \
             github.com/cpuguy83/go-md2man/v2 \
-            github.com/creack/pty \
             github.com/davecgh/go-spew \
             github.com/felixge/fgprof \
             github.com/fogleman/gg \

CHANGELOG.md

@@ -16,6 +16,13 @@ because it turns other people's test suites red.
 
 ### Added
 
+- **The window says where the files will go, and lets you browse to it.** The
+  output directory is written out in full instead of as a dot, and there is a
+  Choose button beside it. A dot is clear in a terminal, where you walked into
+  the directory yourself. Started from a desktop it means somewhere, and this is
+  the part of the tool that writes into your directories.
+  The box is still a box, so a path somebody sent you can be pasted straight in.
+
 - **Presets in the window.** A second screen that starts from a question rather
   than from numbers: pick what you are testing, and the set is worked out from
   the answer. It shows the question the preset closes and the mistakes it

THIRD-PARTY-NOTICES.md

@@ -119,19 +119,25 @@ Source: <https://go.googlesource.com/text>
 
 ## The window binary only
 
-These 25 modules are the graphics toolkit and what it brings with it. They are
+These 26 modules are the graphics toolkit and what it brings with it. They are
 in `tfg-gui` and in no other binary this project produces.
 
 Their licences were read from the source of each module before the toolkit was
 added, on 2026-08-05. All are permissive and one way compatible with GPL-3.0:
-eleven BSD 3-Clause, nine MIT, one Apache-2.0, one BSD 2-Clause and one ISC.
+twelve BSD 3-Clause, nine MIT, one Apache-2.0, one BSD 2-Clause and one ISC.
 None is GPL-2.0-only or LGPL, which would not have been compatible.
 
+One arrived later than the rest. `github.com/FyshOS/fancyfs` came in on the
+same day with the folder picker, because the toolkit's dialog package
+imports it to decorate folder icons. Its licence was read before it was
+accepted, the same as the others.
+
 | module | version | licence | copyright |
 |---|---|---|---|
 | `fyne.io/fyne/v2` | v2.8.0 | BSD-3-Clause | (C) 2018 Fyne.io developers (see AUTHORS) |
 | `fyne.io/systray` | v1.12.2 | Apache-2.0 | 2014 Brave New Software Project, Inc. |
 | `github.com/BurntSushi/toml` | v1.6.0 | MIT | (c) 2013 TOML authors |
+| `github.com/FyshOS/fancyfs` | v0.0.1 | BSD-3-Clause | (C) 2025 FyshOS developers (see AUTHORS) |
 | `github.com/anthonynsimon/bild` | v0.14.0 | MIT | (c) 2021 Anthony Najjar Simon |
 | `github.com/clipperhouse/uax29/v2` | v2.2.0 | MIT | (c) 2020 Matt Sherman |
 | `github.com/fredbi/uri` | v1.1.1 | MIT | (c) 2018 Frederic Bidon |

go.mod

@@ -10,6 +10,8 @@ require github.com/goccy/go-yaml v1.19.2
 
 require golang.org/x/text v0.40.0
 
+require github.com/FyshOS/fancyfs v0.0.1 // indirect
+
 require (
 	fyne.io/fyne/v2 v2.8.0
 	fyne.io/systray v1.12.2 // indirect
@@ -32,7 +34,6 @@ require (
 	github.com/hack-pad/safejs v0.1.0 // indirect
 	github.com/jeandeaual/go-locale v0.0.0-20250612000132-0ef82f21eade // indirect
 	github.com/jsummers/gobmp v0.0.0-20230614200233-a9de23ed2e25 // indirect
-	github.com/kr/text v0.2.0 // indirect
 	github.com/mattn/go-runewidth v0.0.24 // indirect
 	github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 // indirect
 	github.com/nicksnyder/go-i18n/v2 v2.5.1 // indirect

go.sum

@@ -4,11 +4,12 @@ fyne.io/systray v1.12.2 h1:Y8DZxgLHsVQt6rY9Zrkkg+j67S7vv/1F2viOWKPpVeA=
 fyne.io/systray v1.12.2/go.mod h1:RVwqP9nYMo7h5zViCBHri2FgjXF7H2cub7MAq4NSoLs=
 github.com/BurntSushi/toml v1.6.0 h1:dRaEfpa2VI55EwlIW72hMRHdWouJeRF7TPYhI+AUQjk=
 github.com/BurntSushi/toml v1.6.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
+github.com/FyshOS/fancyfs v0.0.1 h1:kgvm7VvwOMLkYTqSflplp62SlMVWQ2uAoHw9CXwXHYg=
+github.com/FyshOS/fancyfs v0.0.1/go.mod h1:S5SHVz/5R72iCXOxCqdcyTPSlg3JxNd0gaHyGBSrY8A=
 github.com/anthonynsimon/bild v0.14.0 h1:IFRkmKdNdqmexXHfEU7rPlAmdUZ8BDZEGtGHDnGWync=
 github.com/anthonynsimon/bild v0.14.0/go.mod h1:hcvEAyBjTW69qkKJTfpcDQ83sSZHxwOunsseDfeQhUs=
 github.com/clipperhouse/uax29/v2 v2.2.0 h1:ChwIKnQN3kcZteTXMgb1wztSgaU+ZemkgWdohwgs8tY=
 github.com/clipperhouse/uax29/v2 v2.2.0/go.mod h1:EFJ2TJMRUaplDxHKj1qAEhCtQPW2tJSwu5BF98AuoVM=
-github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/felixge/fgprof v0.9.3 h1:VvyZxILNuCiUCSXtPtYmmtGvb65nqXh2QFWc0Wpf2/g=

internal/format/format.go

@@ -147,6 +147,18 @@ type Property struct {
 	// Choices are the allowed values of a choice, lower case.
 	Choices []string
 
+	// Shape is what free text has to look like, in a few words, for a kind that
+	// has no range and no closed set to describe itself with.
+	//
+	// It exists because "text" was the whole of what a text setting could say
+	// about itself, and under a field that reads as no description at all -
+	// seen on screen on 2026-08-05, where the spread of a boundary set was
+	// announced as "text, default 1B,1kb,1mb". The value it wants is a list of
+	// sizes separated by commas, the declaration knew that, and there was
+	// nowhere to put it. Ignored by every other kind, which say what they take
+	// from their own range or set.
+	Shape string
+
 	// Default is what the format uses when nothing says otherwise, written
 	// the way a person would write it. Empty means the format works it out -
 	// a picture size chosen to fit the requested bytes, for instance.
@@ -421,7 +433,12 @@ func (p Property) Allowed() string {
 	case PropertySize:
 		what = "a size such as 2mb, or a plain byte count"
 	default:
-		what = "text"
+		// A text setting describes itself with Shape or not at all. Saying
+		// "text" under a field is a word where a description should be.
+		what = p.Shape
+	}
+	if p.Default != "" && what == "" {
+		return "default " + p.Default
 	}
 	if p.Default != "" {
 		what += ", default " + p.Default

internal/format/targz/targz.go

@@ -137,6 +137,7 @@ func init() {
 			},
 			{
 				Name: "entry_format", Kind: format.PropertyText,
+				Shape: "the id of a format, as tfg formats lists them",
 				// Not a choice, for the same reason as in ZIP: the allowed
 				// values are whatever this build registered, and a list frozen
 				// here would drift the moment a format is added.

internal/format/zip/zip.go

@@ -107,6 +107,7 @@ func init() {
 			},
 			{
 				Name: "entry_format", Kind: format.PropertyText,
+				Shape: "the id of a format, as tfg formats lists them",
 				// Not a choice, because the allowed values are whatever this
 				// build registered, and a list frozen here would drift away
 				// from the registry the moment a format is added.

internal/guard/notices_test.go

@@ -5,6 +5,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"regexp"
+	"sort"
 	"strings"
 	"testing"
 )
@@ -27,6 +28,35 @@ import (
 // is a licence question and belongs to a person reading each licence, and a
 // guard that added rows automatically would defeat the reason the file exists.
 
+// unlisted is every module the binary carries that the notices do not name.
+//
+// The standard library is not a module and does not appear in the build
+// list, so nothing has to be excluded here - what comes back is third party
+// code that ships.
+func unlisted(body string, built map[string]string) []string {
+	// Two ways of being named, because this file uses both. Most modules get
+	// a row in a table. The two that carry the command line get a section of
+	// their own with the whole licence text under a heading, which is a
+	// stronger notice rather than a weaker one - reading only the rows called
+	// them missing the first time this ran.
+	named := map[string]bool{}
+	for _, line := range strings.Split(body, "\n") {
+		if m := noticeRow.FindStringSubmatch(line); m != nil {
+			named[m[1]] = true
+		}
+		if heading, found := strings.CutPrefix(line, "## "); found {
+			named[strings.TrimSpace(heading)] = true
+		}
+	}
+	var missing []string
+	for path := range built {
+		if !named[path] {
+			missing = append(missing, path)
+		}
+	}
+	return missing
+}
+
 var noticeRow = regexp.MustCompile(`^\| ` + "`" + `([^` + "`" + `]+)` + "`" + ` \| (v[^ |]+) \|`)
 
 func TestTheNoticesFileNamesTheVersionsThatAreActuallyBuilt(t *testing.T) {
@@ -65,6 +95,19 @@ func TestTheNoticesFileNamesTheVersionsThatAreActuallyBuilt(t *testing.T) {
 	if listed < 5 {
 		t.Fatalf("only %d rows were compared, so this guard would pass on an empty table", listed)
 	}
+
+	// And the other direction, which is the one that was missing. Until
+	// 2026-08-05 this only asked whether every listed module is still built,
+	// so a module that ARRIVED went unlisted and unnoticed - and it was the
+	// folder picker arriving that showed it. Their licences require the
+	// notice to travel with the code that ships, and an absent notice fails
+	// that in a way a wrong version number does not.
+	if missing := unlisted(string(body), built); len(missing) > 0 {
+		sort.Strings(missing)
+		t.Errorf("%d module(s) are compiled into the window and named nowhere in the notices:\n  %s\n"+
+			"Read the licence out of the module's own source, add a row, and change the counts "+
+			"in the paragraph above the table.", len(missing), strings.Join(missing, "\n  "))
+	}
 	t.Logf("%d module version(s) in the notices agree with what the window binary links", listed)
 }
 

internal/guard/presetwindow_test.go

@@ -12,6 +12,8 @@ import (
 	"fyne.io/fyne/v2/widget"
 
 	"github.com/donislawdev/TestingFilesGenerator/internal/cli"
+	"github.com/donislawdev/TestingFilesGenerator/internal/format"
+	"github.com/donislawdev/TestingFilesGenerator/internal/gui/window"
 	"github.com/donislawdev/TestingFilesGenerator/internal/preset"
 )
 
@@ -253,3 +255,144 @@ func hashLine(recorded string) string {
 	}
 	return ""
 }
+
+// Where the files will land is legible before the button is pressed.
+//
+// In a terminal a dot is the directory you typed your way into. A window
+// started from a desktop has a working directory nobody chose and nobody can
+// see, so the same dot means "somewhere" - and this is the one part of this
+// tool that writes into other people's directories. The destination is
+// unchanged, what changed is that it can be read.
+func TestBothScreensSayWhereTheFilesWillGo(t *testing.T) {
+	host, generate := screen(t)
+	press(t, generate, "Presets")
+
+	for name, content := range map[string]fyne.CanvasObject{
+		"the generate screen": generate,
+		"the preset screen":   host.content,
+	} {
+		shown := entryUnder(t, content, "output directory").Text
+		if shown == "." || shown == "" {
+			t.Errorf("%s offers %q as the output directory, which says nothing about where the files go",
+				name, shown)
+			continue
+		}
+		if !filepath.IsAbs(shown) {
+			t.Errorf("%s offers %q, which is not a path somebody can read off the screen", name, shown)
+		}
+	}
+}
+
+// A text setting says what sort of text it takes.
+//
+// "text" was the whole of what a text setting could say about itself, and under
+// a field that reads as no description at all - seen on screen on 2026-08-05 as
+// "text, default 1B,1kb,1mb", where the value wanted is a list of sizes. The
+// declaration knew that and had nowhere to put it.
+func TestNoTextSettingDescribesItselfAsText(t *testing.T) {
+	checked := 0
+	for _, p := range preset.All() {
+		for _, param := range p.Parameters {
+			if param.Kind != format.PropertyText {
+				continue
+			}
+			checked++
+			if strings.HasPrefix(param.Allowed(), "text") {
+				t.Errorf("%s.%s announces itself as %q, which is a word where a description should be",
+					p.ID, param.Name, param.Allowed())
+			}
+			if param.Shape == "" {
+				t.Errorf("%s.%s is free text and declares no shape, so nothing can say what it takes",
+					p.ID, param.Name)
+			}
+		}
+	}
+	for _, d := range format.All() {
+		for _, param := range d.Properties {
+			if param.Kind == format.PropertyText && param.Shape == "" {
+				t.Errorf("%s.%s is free text and declares no shape", d.ID, param.Name)
+			}
+		}
+	}
+	if checked == 0 {
+		t.Skip("no text setting is declared in this build")
+	}
+	t.Logf("%d text setting(s), each declaring what it takes", checked)
+}
+
+// What a preset typically finds is a list, not a sentence.
+//
+// The entries have commas inside them, so run together they read as three times
+// as many items as there are. Only visible by looking at the screen.
+func TestWhatAPresetFindsIsShownAsSeparateLines(t *testing.T) {
+	_, content := presetScreen(t)
+	picker := controlUnder(content, "preset").(*widget.Select)
+
+	for _, p := range preset.All() {
+		if len(p.Catches) < 2 {
+			continue
+		}
+		picker.SetSelected(p.ID)
+		shown := textIn(content)
+		for _, catch := range p.Catches {
+			if !strings.Contains(shown, "\n"+"   - "+catch+"\n") &&
+				!strings.Contains(shown, "   - "+catch) {
+				t.Errorf("%s: %q is not on a line of its own", p.ID, catch)
+			}
+		}
+		// Joined into one sentence they would share a line with each other.
+		if strings.Contains(shown, p.Catches[0]+" and "+p.Catches[1]) ||
+			strings.Contains(shown, p.Catches[0]+", "+p.Catches[1]) {
+			t.Errorf("%s runs its findings together into one sentence", p.ID)
+		}
+	}
+}
+
+// The browse button reaches the window and its answer lands in the field.
+//
+// A picker needs a real window, so what is provable here is the wiring rather
+// than the dialog: that the button asks, and that what comes back is what the
+// run will use. A button that asks and drops the answer looks exactly like one
+// that works, which is the shape this project keeps meeting.
+func TestBrowsingForADirectoryPutsItInTheField(t *testing.T) {
+	host := &fakeHost{picked: filepath.Join(t.TempDir(), "chosen")}
+	window.Open(host)
+
+	for _, screenName := range []string{"generate", "preset"} {
+		if screenName == "preset" {
+			press(t, host.content, "Presets")
+		}
+		content := host.content
+
+		before := entryUnder(t, content, "output directory").Text
+		press(t, content, "Choose...")
+
+		if host.asked == 0 {
+			t.Fatalf("the %s screen has a browse button that asks nobody", screenName)
+		}
+		after := entryUnder(t, content, "output directory").Text
+		if after == before {
+			t.Errorf("the %s screen dropped the directory that was chosen, so the button does nothing",
+				screenName)
+		}
+		if after != host.picked {
+			t.Errorf("the %s screen holds %q and %q was chosen", screenName, after, host.picked)
+		}
+	}
+}
+
+// Changing your mind leaves the field alone.
+//
+// A picker that is cancelled answers with nothing, and a field emptied by
+// cancelling would send the run at a directory nobody named.
+func TestCancellingTheDirectoryPickerLeavesTheFieldAlone(t *testing.T) {
+	host := &fakeHost{} // picked is empty, so nothing is chosen
+	window.Open(host)
+
+	before := entryUnder(t, host.content, "output directory").Text
+	press(t, host.content, "Choose...")
+
+	if after := entryUnder(t, host.content, "output directory").Text; after != before {
+		t.Errorf("cancelling the picker changed the field from %q to %q", before, after)
+	}
+}