refactor #39,#40: implement application layer and improve test coverage

- Create application layer with RenderService, ValidateService, InfoService
- Move orchestration logic (filterPages, collectFonts) from cmd to application
- Simplify cmd/ to only handle CLI concerns (flags, I/O, user prompts)
- Remove empty .gitkeep placeholders from vertical-slice application dirs
- Add tests for CollectFontRefs, buildFilename, buildCSSURL, fallbackStyleKey,
  intrinsicSize, and crossOffset
- Coverage: 55.0% → 64.3%

Closes #39
Closes #40

Author: vpedrosa

cmd/info.go

@@ -6,8 +6,8 @@ import (
 	"sort"
 
 	"github.com/spf13/cobra"
+	"github.com/vpedrosa/pen2pdf/internal/application"
 	parserInfra "github.com/vpedrosa/pen2pdf/internal/parser/infrastructure"
-	shared "github.com/vpedrosa/pen2pdf/internal/shared/domain"
 )
 
 var infoCmd = &cobra.Command{
@@ -31,74 +31,43 @@ func runInfo(cmd *cobra.Command, args []string) error {
 	}
 	defer inputFile.Close() //nolint:errcheck
 
-	parser := parserInfra.NewJSONParser()
-	doc, err := parser.Parse(inputFile)
+	svc := application.NewInfoService(parserInfra.NewJSONParser())
+
+	info, err := svc.GetInfo(inputFile)
 	if err != nil {
-		return fmt.Errorf("parse error: %w", err)
+		return err
 	}
 
 	cmd.Printf("File:    %s\n", inputPath)
-	cmd.Printf("Version: %s\n", doc.Version)
+	cmd.Printf("Version: %s\n", info.Version)
 	cmd.Println()
 
-	// Pages
-	cmd.Printf("Pages (%d):\n", len(doc.Children))
-	for _, child := range doc.Children {
-		if frame, ok := child.(*shared.Frame); ok {
-			cmd.Printf("  - %s (%.0fx%.0f)\n", frame.Name, frame.Width.Value, frame.Height.Value)
-		}
+	cmd.Printf("Pages (%d):\n", len(info.Pages))
+	for _, page := range info.Pages {
+		cmd.Printf("  - %s (%.0fx%.0f)\n", page.Name, page.Width, page.Height)
 	}
 	cmd.Println()
 
-	// Variables
-	if len(doc.Variables) > 0 {
-		cmd.Printf("Variables (%d):\n", len(doc.Variables))
-		names := make([]string, 0, len(doc.Variables))
-		for name := range doc.Variables {
+	if len(info.Variables) > 0 {
+		cmd.Printf("Variables (%d):\n", len(info.Variables))
+		names := make([]string, 0, len(info.Variables))
+		for name := range info.Variables {
 			names = append(names, name)
 		}
 		sort.Strings(names)
 		for _, name := range names {
-			v := doc.Variables[name]
+			v := info.Variables[name]
 			cmd.Printf("  %-20s %s = %v\n", name, v.Type, v.Value)
 		}
 		cmd.Println()
 	}
 
-	// Fonts
-	fonts := collectFonts(doc.Children)
-	if len(fonts) > 0 {
-		cmd.Printf("Fonts (%d):\n", len(fonts))
-		for _, f := range fonts {
+	if len(info.Fonts) > 0 {
+		cmd.Printf("Fonts (%d):\n", len(info.Fonts))
+		for _, f := range info.Fonts {
 			cmd.Printf("  - %s\n", f)
 		}
 	}
 
 	return nil
 }
-
-// collectFonts walks the node tree and returns sorted unique font families.
-func collectFonts(nodes []shared.Node) []string {
-	fontSet := make(map[string]bool)
-	walkFonts(nodes, fontSet)
-
-	fonts := make([]string, 0, len(fontSet))
-	for f := range fontSet {
-		fonts = append(fonts, f)
-	}
-	sort.Strings(fonts)
-	return fonts
-}
-
-func walkFonts(nodes []shared.Node, fonts map[string]bool) {
-	for _, node := range nodes {
-		switch n := node.(type) {
-		case *shared.Frame:
-			walkFonts(n.Children, fonts)
-		case *shared.Text:
-			if n.FontFamily != "" {
-				fonts[n.FontFamily] = true
-			}
-		}
-	}
-}

cmd/info_test.go

@@ -2,8 +2,6 @@ package cmd
 
 import (
 	"testing"
-
-	shared "github.com/vpedrosa/pen2pdf/internal/shared/domain"
 )
 
 func TestInfoCommandRegistered(t *testing.T) {
@@ -25,60 +23,3 @@ func TestInfoCommandRequiresArg(t *testing.T) {
 		t.Error("expected error for missing argument")
 	}
 }
-
-func TestCollectFonts(t *testing.T) {
-	nodes := []shared.Node{
-		&shared.Frame{
-			ID: "f1", Name: "page",
-			Children: []shared.Node{
-				&shared.Text{ID: "t1", Name: "a", FontFamily: "Inter"},
-				&shared.Text{ID: "t2", Name: "b", FontFamily: "Montserrat"},
-				&shared.Text{ID: "t3", Name: "c", FontFamily: "Inter"}, // duplicate
-				&shared.Frame{
-					ID: "f2", Name: "inner",
-					Children: []shared.Node{
-						&shared.Text{ID: "t4", Name: "d", FontFamily: "Playfair Display"},
-					},
-				},
-			},
-		},
-	}
-
-	fonts := collectFonts(nodes)
-	if len(fonts) != 3 {
-		t.Fatalf("expected 3 unique fonts, got %d: %v", len(fonts), fonts)
-	}
-	// Should be sorted
-	expected := []string{"Inter", "Montserrat", "Playfair Display"}
-	for i, f := range fonts {
-		if f != expected[i] {
-			t.Errorf("expected fonts[%d] '%s', got '%s'", i, expected[i], f)
-		}
-	}
-}
-
-func TestCollectFontsEmpty(t *testing.T) {
-	nodes := []shared.Node{
-		&shared.Frame{ID: "f1", Name: "empty"},
-	}
-
-	fonts := collectFonts(nodes)
-	if len(fonts) != 0 {
-		t.Errorf("expected 0 fonts, got %d", len(fonts))
-	}
-}
-
-func TestCollectFontsSkipsEmptyFamily(t *testing.T) {
-	nodes := []shared.Node{
-		&shared.Text{ID: "t1", Name: "a", FontFamily: ""},
-		&shared.Text{ID: "t2", Name: "b", FontFamily: "Inter"},
-	}
-
-	fonts := collectFonts(nodes)
-	if len(fonts) != 1 {
-		t.Fatalf("expected 1 font, got %d", len(fonts))
-	}
-	if fonts[0] != "Inter" {
-		t.Errorf("expected 'Inter', got '%s'", fonts[0])
-	}
-}

cmd/render.go

@@ -8,6 +8,7 @@ import (
 	"strings"
 
 	"github.com/spf13/cobra"
+	"github.com/vpedrosa/pen2pdf/internal/application"
 	assetInfra "github.com/vpedrosa/pen2pdf/internal/asset/infrastructure"
 	layoutInfra "github.com/vpedrosa/pen2pdf/internal/layout/infrastructure"
 	parserInfra "github.com/vpedrosa/pen2pdf/internal/parser/infrastructure"
@@ -47,88 +48,60 @@ func runRender(cmd *cobra.Command, args []string) error {
 		output = strings.TrimSuffix(inputPath, ext) + ".pdf"
 	}
 
-	// Parse
-	inputFile, err := os.Open(inputPath)
-	if err != nil {
-		return fmt.Errorf("open input: %w", err)
-	}
-	defer inputFile.Close() //nolint:errcheck
-
-	parser := parserInfra.NewJSONParser()
-	doc, err := parser.Parse(inputFile)
-	if err != nil {
-		return fmt.Errorf("parse: %w", err)
-	}
-
-	// Resolve variables
-	resolver := resolverInfra.NewVariableResolver()
-	if err := resolver.Resolve(doc); err != nil {
-		return fmt.Errorf("resolve: %w", err)
-	}
-
-	// Filter pages if --pages flag is set
-	if pagesFlag != "" {
-		doc.Children, err = filterPages(doc.Children, pagesFlag)
-		if err != nil {
-			return err
-		}
-	}
-
-	// Set up asset loaders
+	// Build infrastructure
 	baseDir := filepath.Dir(inputPath)
-	imageLoader := assetInfra.NewFSImageLoader(baseDir)
 	fontsDir := filepath.Join(baseDir, "fonts")
 
 	fontDirs := []string{fontsDir, "/usr/share/fonts", "/usr/local/share/fonts"}
 	if home, err := os.UserHomeDir(); err == nil {
 		fontDirs = append(fontDirs, filepath.Join(home, ".local", "share", "fonts"))
 	}
+
+	parser := parserInfra.NewJSONParser()
+	resolver := resolverInfra.NewVariableResolver()
 	fontLoader := assetInfra.NewFSFontLoader(fontDirs...)
+	imageLoader := assetInfra.NewFSImageLoader(baseDir)
+	measurer := layoutInfra.NewGopdfTextMeasurer(fontLoader)
+	layoutEngine := layoutInfra.NewFlexboxEngine()
+	renderer := rendererInfra.NewPDFRenderer(imageLoader, fontLoader)
 
-	// Check for missing fonts and offer to download
-	if err := checkAndDownloadFonts(cmd, doc, fontLoader, fontsDir); err != nil {
-		return err
+	svc := application.NewRenderService(parser, resolver, fontLoader, imageLoader, layoutEngine, measurer, renderer)
+
+	// Check for missing fonts (interactive CLI concern)
+	inputFile, err := os.Open(inputPath)
+	if err != nil {
+		return fmt.Errorf("open input: %w", err)
 	}
 
-	// Layout
-	measurer := layoutInfra.NewGopdfTextMeasurer(fontLoader)
-	layoutEngine := layoutInfra.NewFlexboxEngine()
-	pages, err := layoutEngine.Layout(doc, measurer)
+	missing, doc, err := svc.DetectMissingFonts(inputFile)
+	inputFile.Close() //nolint:errcheck
 	if err != nil {
-		return fmt.Errorf("layout: %w", err)
+		return err
+	}
+
+	if len(missing) > 0 {
+		if err := promptAndDownloadFonts(cmd, missing, fontsDir); err != nil {
+			return err
+		}
 	}
 
-	// Render
+	// Render using the already-parsed document
 	outputFile, err := os.Create(output)
 	if err != nil {
 		return fmt.Errorf("create output: %w", err)
 	}
 	defer outputFile.Close() //nolint:errcheck
 
-	renderer := rendererInfra.NewPDFRenderer(imageLoader, fontLoader)
-	if err := renderer.Render(pages, outputFile); err != nil {
-		return fmt.Errorf("render: %w", err)
+	result, err := svc.RenderDocument(doc, outputFile, pagesFlag)
+	if err != nil {
+		return err
 	}
 
-	cmd.Printf("PDF written to %s (%d pages)\n", output, len(pages))
+	cmd.Printf("PDF written to %s (%d pages)\n", output, result.PageCount)
 	return nil
 }
 
-func checkAndDownloadFonts(cmd *cobra.Command, doc *shared.Document, fontLoader *assetInfra.FSFontLoader, fontsDir string) error {
-	refs := shared.CollectFontRefs(doc)
-
-	var missing []shared.FontRef
-	for _, ref := range refs {
-		_, err := fontLoader.LoadFont(ref.Family, ref.Weight, ref.Style)
-		if err != nil {
-			missing = append(missing, ref)
-		}
-	}
-
-	if len(missing) == 0 {
-		return nil
-	}
-
+func promptAndDownloadFonts(cmd *cobra.Command, missing []shared.FontRef, fontsDir string) error {
 	cmd.Printf("Missing %d font(s):\n", len(missing))
 	for _, ref := range missing {
 		label := ref.Family + " " + ref.Weight
@@ -171,23 +144,3 @@ func checkAndDownloadFonts(cmd *cobra.Command, doc *shared.Document, fontLoader
 
 	return nil
 }
-
-func filterPages(children []shared.Node, names string) ([]shared.Node, error) {
-	nameList := strings.Split(names, ",")
-	nameSet := make(map[string]bool, len(nameList))
-	for _, n := range nameList {
-		nameSet[strings.TrimSpace(n)] = true
-	}
-
-	var filtered []shared.Node
-	for _, child := range children {
-		if nameSet[child.GetName()] {
-			filtered = append(filtered, child)
-		}
-	}
-
-	if len(filtered) == 0 {
-		return nil, fmt.Errorf("no pages match --pages %q", names)
-	}
-	return filtered, nil
-}

cmd/render_test.go

@@ -2,8 +2,6 @@ package cmd
 
 import (
 	"testing"
-
-	shared "github.com/vpedrosa/pen2pdf/internal/shared/domain"
 )
 
 func TestRenderCommandRegistered(t *testing.T) {
@@ -43,47 +41,9 @@ func TestRenderCommandRequiresArg(t *testing.T) {
 	}
 }
 
-func TestFilterPagesMatchSingle(t *testing.T) {
-	children := []shared.Node{
-		&shared.Frame{ID: "p1", Name: "Front"},
-		&shared.Frame{ID: "p2", Name: "Back"},
-	}
-
-	filtered, err := filterPages(children, "Front")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(filtered) != 1 {
-		t.Fatalf("expected 1 page, got %d", len(filtered))
-	}
-	if filtered[0].GetName() != "Front" {
-		t.Errorf("expected 'Front', got '%s'", filtered[0].GetName())
-	}
-}
-
-func TestFilterPagesMatchMultiple(t *testing.T) {
-	children := []shared.Node{
-		&shared.Frame{ID: "p1", Name: "Front"},
-		&shared.Frame{ID: "p2", Name: "Back"},
-		&shared.Frame{ID: "p3", Name: "Extra"},
-	}
-
-	filtered, err := filterPages(children, "Front,Back")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(filtered) != 2 {
-		t.Fatalf("expected 2 pages, got %d", len(filtered))
-	}
-}
-
-func TestFilterPagesNoMatch(t *testing.T) {
-	children := []shared.Node{
-		&shared.Frame{ID: "p1", Name: "Front"},
-	}
-
-	_, err := filterPages(children, "NonExistent")
-	if err == nil {
-		t.Fatal("expected error for no matching pages")
+func TestRenderCommandHasNoPromptFlag(t *testing.T) {
+	f := renderCmd.Flags().Lookup("no-prompt")
+	if f == nil {
+		t.Error("expected --no-prompt flag")
 	}
 }