refactor #39: distribute application layer into vertical slices with DI

- Create application service in each vertical slice:
  parser/application/ParseService, resolver/application/ResolveService,
  asset/application/FontService, layout/application/LayoutService,
  renderer/application/RenderService
- Each service receives domain port interfaces via constructor injection
- Move filterPages to shared/domain/FilterPagesByName
- Add shared/domain/CollectFontFamilies (replaces duplicate collectFonts)
- cmd/ acts as composition root: creates infrastructure, injects into services
- Delete cross-cutting internal/application/ package
- All application services tested with stubs (100% coverage each)

Closes #39

Author: vpedrosa

cmd/info.go

@@ -6,8 +6,9 @@ import (
 	"sort"
 
 	"github.com/spf13/cobra"
-	"github.com/vpedrosa/pen2pdf/internal/application"
+	parserApp "github.com/vpedrosa/pen2pdf/internal/parser/application"
 	parserInfra "github.com/vpedrosa/pen2pdf/internal/parser/infrastructure"
+	shared "github.com/vpedrosa/pen2pdf/internal/shared/domain"
 )
 
 var infoCmd = &cobra.Command{
@@ -31,40 +32,43 @@ func runInfo(cmd *cobra.Command, args []string) error {
 	}
 	defer inputFile.Close() //nolint:errcheck
 
-	svc := application.NewInfoService(parserInfra.NewJSONParser())
+	parseSvc := parserApp.NewParseService(parserInfra.NewJSONParser())
 
-	info, err := svc.GetInfo(inputFile)
+	doc, err := parseSvc.Parse(inputFile)
 	if err != nil {
-		return err
+		return fmt.Errorf("parse error: %w", err)
 	}
 
 	cmd.Printf("File:    %s\n", inputPath)
-	cmd.Printf("Version: %s\n", info.Version)
+	cmd.Printf("Version: %s\n", doc.Version)
 	cmd.Println()
 
-	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.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.Println()
 
-	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 {
+	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 {
 			names = append(names, name)
 		}
 		sort.Strings(names)
 		for _, name := range names {
-			v := info.Variables[name]
+			v := doc.Variables[name]
 			cmd.Printf("  %-20s %s = %v\n", name, v.Type, v.Value)
 		}
 		cmd.Println()
 	}
 
-	if len(info.Fonts) > 0 {
-		cmd.Printf("Fonts (%d):\n", len(info.Fonts))
-		for _, f := range info.Fonts {
+	fonts := shared.CollectFontFamilies(doc)
+	if len(fonts) > 0 {
+		cmd.Printf("Fonts (%d):\n", len(fonts))
+		for _, f := range fonts {
 			cmd.Printf("  - %s\n", f)
 		}
 	}

cmd/render.go

@@ -8,11 +8,15 @@ import (
 	"strings"
 
 	"github.com/spf13/cobra"
-	"github.com/vpedrosa/pen2pdf/internal/application"
+	assetApp "github.com/vpedrosa/pen2pdf/internal/asset/application"
 	assetInfra "github.com/vpedrosa/pen2pdf/internal/asset/infrastructure"
+	layoutApp "github.com/vpedrosa/pen2pdf/internal/layout/application"
 	layoutInfra "github.com/vpedrosa/pen2pdf/internal/layout/infrastructure"
+	parserApp "github.com/vpedrosa/pen2pdf/internal/parser/application"
 	parserInfra "github.com/vpedrosa/pen2pdf/internal/parser/infrastructure"
+	rendererApp "github.com/vpedrosa/pen2pdf/internal/renderer/application"
 	rendererInfra "github.com/vpedrosa/pen2pdf/internal/renderer/infrastructure"
+	resolverApp "github.com/vpedrosa/pen2pdf/internal/resolver/application"
 	resolverInfra "github.com/vpedrosa/pen2pdf/internal/resolver/infrastructure"
 	shared "github.com/vpedrosa/pen2pdf/internal/shared/domain"
 )
@@ -57,44 +61,66 @@ func runRender(cmd *cobra.Command, args []string) error {
 		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)
+	pdfRenderer := rendererInfra.NewPDFRenderer(imageLoader, fontLoader)
 
-	svc := application.NewRenderService(parser, resolver, fontLoader, imageLoader, layoutEngine, measurer, renderer)
+	// Build application services (inject ports via DI)
+	parseSvc := parserApp.NewParseService(parserInfra.NewJSONParser())
+	resolveSvc := resolverApp.NewResolveService(resolverInfra.NewVariableResolver())
+	fontSvc := assetApp.NewFontService(fontLoader)
+	layoutSvc := layoutApp.NewLayoutService(layoutInfra.NewFlexboxEngine(), measurer)
+	renderSvc := rendererApp.NewRenderService(pdfRenderer)
 
-	// Check for missing fonts (interactive CLI concern)
+	// 1. Parse
 	inputFile, err := os.Open(inputPath)
 	if err != nil {
 		return fmt.Errorf("open input: %w", err)
 	}
-
-	missing, doc, err := svc.DetectMissingFonts(inputFile)
+	doc, err := parseSvc.Parse(inputFile)
 	inputFile.Close() //nolint:errcheck
 	if err != nil {
-		return err
+		return fmt.Errorf("parse: %w", err)
+	}
+
+	// 2. Resolve variables
+	if err := resolveSvc.Resolve(doc); err != nil {
+		return fmt.Errorf("resolve: %w", err)
 	}
 
+	// 3. Detect and download missing fonts (interactive CLI concern)
+	missing := fontSvc.DetectMissingFonts(doc)
 	if len(missing) > 0 {
 		if err := promptAndDownloadFonts(cmd, missing, fontsDir); err != nil {
 			return err
 		}
 	}
 
-	// Render using the already-parsed document
+	// 4. Filter pages
+	if pagesFlag != "" {
+		doc.Children, err = shared.FilterPagesByName(doc.Children, pagesFlag)
+		if err != nil {
+			return err
+		}
+	}
+
+	// 5. Layout
+	pages, err := layoutSvc.Layout(doc)
+	if err != nil {
+		return fmt.Errorf("layout: %w", err)
+	}
+
+	// 6. Render
 	outputFile, err := os.Create(output)
 	if err != nil {
 		return fmt.Errorf("create output: %w", err)
 	}
 	defer outputFile.Close() //nolint:errcheck
 
-	result, err := svc.RenderDocument(doc, outputFile, pagesFlag)
+	result, err := renderSvc.Render(pages, outputFile)
 	if err != nil {
-		return err
+		return fmt.Errorf("render: %w", err)
 	}
 
 	cmd.Printf("PDF written to %s (%d pages)\n", output, result.PageCount)

cmd/validate.go

@@ -5,8 +5,9 @@ import (
 	"os"
 
 	"github.com/spf13/cobra"
-	"github.com/vpedrosa/pen2pdf/internal/application"
+	parserApp "github.com/vpedrosa/pen2pdf/internal/parser/application"
 	parserInfra "github.com/vpedrosa/pen2pdf/internal/parser/infrastructure"
+	resolverApp "github.com/vpedrosa/pen2pdf/internal/resolver/application"
 	resolverInfra "github.com/vpedrosa/pen2pdf/internal/resolver/infrastructure"
 )
 
@@ -31,16 +32,18 @@ func runValidate(cmd *cobra.Command, args []string) error {
 	}
 	defer inputFile.Close() //nolint:errcheck
 
-	svc := application.NewValidateService(
-		parserInfra.NewJSONParser(),
-		resolverInfra.NewVariableResolver(),
-	)
+	parseSvc := parserApp.NewParseService(parserInfra.NewJSONParser())
+	resolveSvc := resolverApp.NewResolveService(resolverInfra.NewVariableResolver())
 
-	result, err := svc.Validate(inputFile)
+	doc, err := parseSvc.Parse(inputFile)
 	if err != nil {
-		return err
+		return fmt.Errorf("parse error: %w", err)
 	}
 
-	cmd.Printf("Valid: %s (%d pages, %d variables)\n", inputPath, result.PageCount, result.VariableCount)
+	if err := resolveSvc.Resolve(doc); err != nil {
+		return fmt.Errorf("resolve error: %w", err)
+	}
+
+	cmd.Printf("Valid: %s (%d pages, %d variables)\n", inputPath, len(doc.Children), len(doc.Variables))
 	return nil
 }