better domain isolation

internal/writing/html/fragment.go

@@ -0,0 +1,69 @@
+package html
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/nmoniz/any2anexoj/internal"
+	"github.com/nmoniz/any2anexoj/internal/writing/internal/tabledef"
+)
+
+// htmlCSSClass is the CSS class list put on the rendered report table.
+const htmlCSSClass = "table table-striped table-hover table-bordered"
+
+// widthIndex is the weight of the auto-index (row number) column; the other
+// column weights come from tabledef's width budgets.
+const widthIndex = 6
+
+// htmlColumnWeights lists one weight per rendered column, starting with the
+// auto-index column, mirroring the column order of tabledef.Build so the
+// HTML table keeps columns in the same strict proportion to each other as
+// the terminal layout.
+var htmlColumnWeights = []int{
+	widthIndex,
+	tabledef.WidthCountry, tabledef.WidthOther, tabledef.WidthOther, tabledef.WidthOther, tabledef.WidthOther, tabledef.WidthEuros,
+	tabledef.WidthOther, tabledef.WidthOther, tabledef.WidthOther, tabledef.WidthEuros,
+	tabledef.WidthEuros, tabledef.WidthEuros, tabledef.WidthCountry,
+}
+
+// renderTableFragment renders aw as the Bootstrap-styled HTML <table>
+// fragment embedded in the document. The table gets a fixed layout with
+// strictly proportional column widths, so the browser — not this package —
+// decides when a header or cell wraps: on wide screens everything fits on
+// one line, on narrow ones it wraps automatically.
+func (hw *Writer) renderTableFragment(aw *internal.AggregatorWriter) string {
+	t := tabledef.Build(hw.translator, aw)
+	t.Style().HTML = table.HTMLOptions{
+		CSSClass:    htmlCSSClass,
+		EscapeText:  true,
+		Newline:     "<br/>",
+		EmptyColumn: "&nbsp;",
+	}
+	html := t.RenderHTML()
+
+	// go-pretty cannot emit table-level attributes or a <colgroup>, so splice
+	// them into its output: the fixed layout makes the colgroup's relative
+	// widths authoritative instead of content-driven column sizing.
+	openTag := `<table class="` + htmlCSSClass + `">`
+	fixedTag := `<table class="` + htmlCSSClass + `" style="table-layout: fixed">` + "\n" + colgroupHTML()
+	return strings.Replace(html, openTag, fixedTag, 1)
+}
+
+// colgroupHTML returns a <colgroup> with one <col> per rendered column, each
+// sized strictly in proportion to its weight. With the fixed table layout
+// applied in renderTableFragment these widths are authoritative: wide
+// viewports fit headers on a single line, narrow ones wrap automatically.
+func colgroupHTML() string {
+	var total int
+	for _, w := range htmlColumnWeights {
+		total += w
+	}
+	var sb strings.Builder
+	sb.WriteString("<colgroup>")
+	for _, w := range htmlColumnWeights {
+		fmt.Fprintf(&sb, `<col style="width: %.2f%%">`, float64(w)/float64(total)*100)
+	}
+	sb.WriteString("</colgroup>")
+	return sb.String()
+}

internal/writing/html/fragment_test.go

@@ -0,0 +1,60 @@
+package html_test
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"github.com/nmoniz/any2anexoj/internal/writing"
+	htmlwriter "github.com/nmoniz/any2anexoj/internal/writing/html"
+)
+
+// TestWriter_RenderTableFragment renders a Portuguese document and asserts
+// the embedded report table fragment carries the shared structure: the
+// translated headers, the totals footer, and the strictly proportional
+// colgroup that keeps HTML columns in the same relation to each other as
+// the terminal layout.
+func TestWriter_RenderTableFragment(t *testing.T) {
+	aw := buildTestAggregator(t)
+
+	localizer, err := writing.NewLocalizer("pt")
+	if err != nil {
+		t.Fatalf("failed to create localizer: %v", err)
+	}
+
+	var buf bytes.Buffer
+	hw := htmlwriter.NewWriter(&buf, localizer, "pt")
+
+	if err := hw.Render(aw); err != nil {
+		t.Fatalf("Render returned an error: %v", err)
+	}
+	got := buf.String()
+
+	wantSubstrings := []string{
+		`<table class="table table-striped table-hover table-bordered" style="table-layout: fixed">`,
+		`<colgroup>`,
+		`</colgroup>`,
+		`<col style="width: 3.03%">`,
+		`<col style="width: 12.12%">`,
+		`</table>`,
+		`<thead>`,
+		`</thead>`,
+		`<tbody>`,
+		`</tbody>`,
+		`<tfoot>`,
+		`</tfoot>`,
+		"Realização",
+		"Aquisição",
+		"Soma",
+	}
+	for _, s := range wantSubstrings {
+		if !strings.Contains(got, s) {
+			t.Errorf("rendered document missing expected substring %q\nGot:\n%s", s, got)
+		}
+	}
+
+	// The fragment must be embedded raw, not HTML-escaped.
+	if strings.Contains(got, "&lt;table") {
+		t.Errorf("table fragment appears to be HTML-escaped; expected raw <table> markup\nGot:\n%s", got)
+	}
+}

internal/writing/html/writer.go

@@ -1,8 +1,8 @@
 // Package html renders an internal.AggregatorWriter as a complete,
-// standalone HTML document built around the same table fragment produced by
-// table.Printer.RenderHTML. The document includes the Bootstrap 5.3
-// stylesheet via CDN and embeds the raw table fragment without HTML-escaping
-// it so the result opens directly in a browser.
+// standalone HTML document: the report table fragment (built from the
+// shared table definition in internal/writing/internal/tabledef, so it can
+// never drift from the terminal layout) embedded in a Bootstrap-styled page
+// with a translated title and generation timestamp.
 package html
 
 import (
@@ -13,15 +13,9 @@ import (
 	"time"
 
 	"github.com/nmoniz/any2anexoj/internal"
-	"github.com/nmoniz/any2anexoj/internal/writing/table"
+	"github.com/nmoniz/any2anexoj/internal/writing/internal/tabledef"
 )
 
-// translator is the contract the HTML writer relies on for localized
-// document text such as the page title. *writing.Localizer satisfies it.
-type translator interface {
-	Translate(key string, count int, values map[string]any) string
-}
-
 // bootstrapCSSURL is the jsDelivr CDN URL for Bootstrap 5.3.3.
 const bootstrapCSSURL = "https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css"
 
@@ -31,20 +25,17 @@ const bootstrapIntegrity = "sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bR
 // Writer writes a complete HTML document for an AggregatorWriter.
 type Writer struct {
 	output     io.Writer
-	printer    *table.Printer
-	translator translator
+	translator tabledef.Translator
 	lang       string
 }
 
-// NewWriter builds a Writer that writes a complete HTML document to
-// w. The printer is used purely as a source for the raw <table> fragment via
-// RenderHTML; this writer never invokes Render or any method that writes to
-// printer's own io.Writer. The document title is looked up from the
-// "report_title" translation via tr, so callers never pass a pre-baked title.
-func NewWriter(w io.Writer, printer *table.Printer, tr translator, lang string) *Writer {
+// NewWriter builds a Writer that writes a complete HTML document to w. The
+// report table is rendered from the shared table definition via tr, and the
+// document title is looked up from the "report_title" translation via tr,
+// so callers never pass a pre-baked title.
+func NewWriter(w io.Writer, tr tabledef.Translator, lang string) *Writer {
 	return &Writer{
 		output:     w,
-		printer:    printer,
 		translator: tr,
 		lang:       lang,
 	}
@@ -63,10 +54,7 @@ var documentTemplate = template.Must(template.New("html").Parse(documentTemplate
 // fragment from aw so the rendered <tr> count reflects aw's current items and
 // no rows are duplicated across invocations.
 func (hw *Writer) Render(aw *internal.AggregatorWriter) error {
-	if hw.printer == nil {
-		return fmt.Errorf("html: nil printer")
-	}
-	fragment := hw.printer.RenderHTML(aw)
+	fragment := hw.renderTableFragment(aw)
 	title := hw.translator.Translate("report_title", 1, nil)
 	data := struct {
 		Lang          string

internal/writing/html/writer_test.go

@@ -6,10 +6,9 @@ import (
 	"testing"
 	"time"
 
-	htmlwriter "github.com/nmoniz/any2anexoj/internal/writing/html"
-	"github.com/nmoniz/any2anexoj/internal/writing/table"
-	"github.com/nmoniz/any2anexoj/internal/writing"
 	"github.com/nmoniz/any2anexoj/internal"
+	"github.com/nmoniz/any2anexoj/internal/writing"
+	htmlwriter "github.com/nmoniz/any2anexoj/internal/writing/html"
 	"github.com/shopspring/decimal"
 )
 
@@ -64,9 +63,7 @@ func TestWriter_Render(t *testing.T) {
 	}
 
 	var buf bytes.Buffer
-	// RenderHTML never writes to the printer's output, so Discard is safe.
-	pp := table.NewPrinter(&buf, loc)
-	hw := htmlwriter.NewWriter(&buf, pp, loc, "en")
+	hw := htmlwriter.NewWriter(&buf, loc, "en")
 
 	if err := hw.Render(buildTestAggregator(t)); err != nil {
 		t.Fatalf("Render returned an error: %v", err)
@@ -86,7 +83,8 @@ func TestWriter_Render(t *testing.T) {
 		`<main class="container-fluid py-4">`,
 		`<h1>Tax report</h1>`,
 		`<div class="table-responsive">`,
-		`<table class="table table-striped table-hover table-bordered">`,
+		`<table class="table table-striped table-hover table-bordered" style="table-layout: fixed">`,
+		`<colgroup>`,
 		`</table>`,
 		`<tfoot>`,
 		`</tfoot>`,
@@ -133,8 +131,7 @@ func TestWriter_NoRowDuplication(t *testing.T) {
 	}
 
 	var buf bytes.Buffer
-	pp := table.NewPrinter(&buf, loc)
-	hw := htmlwriter.NewWriter(&buf, pp, loc, "en")
+	hw := htmlwriter.NewWriter(&buf, loc, "en")
 
 	aw := buildTestAggregator(t)
 
@@ -167,8 +164,7 @@ func TestWriter_LangAttribute(t *testing.T) {
 	}
 
 	var buf bytes.Buffer
-	pp := table.NewPrinter(&buf, loc)
-	hw := htmlwriter.NewWriter(&buf, pp, loc, "pt")
+	hw := htmlwriter.NewWriter(&buf, loc, "pt")
 
 	if err := hw.Render(buildTestAggregator(t)); err != nil {
 		t.Fatalf("Render returned an error: %v", err)