feat(pdfengines): add split feature

pkg/modules/qpdf/doc.go

@@ -2,6 +2,7 @@
 // interface using the QPDF command-line tool. This package allows for:
 //
 // 1. The merging of PDF files.
+// 2. The splitting of PDF files.
 //
 // The path to the QPDF binary must be specified using the QPDK_BIN_PATH
 // environment variable.

pkg/modules/qpdf/qpdf.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"os"
+	"path/filepath"
 
 	"go.uber.org/zap"
 
@@ -45,12 +46,37 @@ func (engine *QPdf) Provision(ctx *gotenberg.Context) error {
 func (engine *QPdf) Validate() error {
 	_, err := os.Stat(engine.binPath)
 	if os.IsNotExist(err) {
-		return fmt.Errorf("QPdf binary path does not exist: %w", err)
+		return fmt.Errorf("QPDF binary path does not exist: %w", err)
 	}
 
 	return nil
 }
 
+// Split splits a given PDF file.
+func (engine *QPdf) Split(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+	var args []string
+	outputPath := fmt.Sprintf("%s/%s", outputDirPath, filepath.Base(inputPath))
+
+	switch mode.Mode {
+	case gotenberg.SplitModePages:
+		args = append(args, inputPath, "--pages", ".", mode.Span, "--", outputPath)
+	default:
+		return nil, fmt.Errorf("split PDFs using mode '%s' with QPDF: %w", mode.Mode, gotenberg.ErrPdfSplitModeNotSupported)
+	}
+
+	cmd, err := gotenberg.CommandContext(ctx, logger, engine.binPath, args...)
+	if err != nil {
+		return nil, fmt.Errorf("create command: %w", err)
+	}
+
+	_, err = cmd.Exec()
+	if err != nil {
+		return nil, fmt.Errorf("split PDFs with QPDF: %w", err)
+	}
+
+	return []string{outputPath}, nil
+}
+
 // Merge combines multiple PDFs into a single PDF.
 func (engine *QPdf) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
 	var args []string

pkg/modules/qpdf/qpdf_test.go

@@ -116,7 +116,7 @@ func TestQPdf_Merge(t *testing.T) {
 				t.Fatalf("expected error but got: %v", err)
 			}
 
-			fs := gotenberg.NewFileSystem()
+			fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))
 			outputDir, err := fs.MkdirAll()
 			if err != nil {
 				t.Fatalf("expected error but got: %v", err)
@@ -142,6 +142,88 @@ func TestQPdf_Merge(t *testing.T) {
 	}
 }
 
+func TestQPdf_Split(t *testing.T) {
+	for _, tc := range []struct {
+		scenario               string
+		ctx                    context.Context
+		mode                   gotenberg.SplitMode
+		inputPath              string
+		expectError            bool
+		expectedError          error
+		expectOutputPathsCount int
+		expectOutputPaths      []string
+	}{
+		{
+			scenario:               "ErrPdfSplitModeNotSupported",
+			expectError:            true,
+			expectedError:          gotenberg.ErrPdfSplitModeNotSupported,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario:               "invalid context",
+			ctx:                    nil,
+			mode:                   gotenberg.SplitMode{Mode: gotenberg.SplitModePages, Span: "1-2"},
+			expectError:            true,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario:               "invalid input path",
+			ctx:                    context.TODO(),
+			mode:                   gotenberg.SplitMode{Mode: gotenberg.SplitModePages, Span: "1-2"},
+			inputPath:              "",
+			expectError:            true,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario:               "success (pages)",
+			ctx:                    context.TODO(),
+			mode:                   gotenberg.SplitMode{Mode: gotenberg.SplitModePages, Span: "1-2"},
+			inputPath:              "/tests/test/testdata/pdfengines/sample1.pdf",
+			expectError:            false,
+			expectOutputPathsCount: 1,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			engine := new(QPdf)
+			err := engine.Provision(nil)
+			if err != nil {
+				t.Fatalf("expected error but got: %v", err)
+			}
+
+			fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))
+			outputDir, err := fs.MkdirAll()
+			if err != nil {
+				t.Fatalf("expected error but got: %v", err)
+			}
+
+			defer func() {
+				err = os.RemoveAll(fs.WorkingDirPath())
+				if err != nil {
+					t.Fatalf("expected no error while cleaning up but got: %v", err)
+				}
+			}()
+
+			outputPaths, err := engine.Split(tc.ctx, zap.NewNop(), tc.mode, tc.inputPath, outputDir)
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+
+			if tc.expectedError != nil && !errors.Is(err, tc.expectedError) {
+				t.Fatalf("expected error %v but got: %v", tc.expectedError, err)
+			}
+
+			if tc.expectOutputPathsCount != len(outputPaths) {
+				t.Errorf("expected %d output paths but got %d", tc.expectOutputPathsCount, len(outputPaths))
+			}
+		})
+	}
+}
+
 func TestQPdf_Convert(t *testing.T) {
 	engine := new(QPdf)
 	err := engine.Convert(context.TODO(), zap.NewNop(), gotenberg.PdfFormats{}, "", "")