108 |
109 |
110 |
--------------------------------------------------------------------------------
/json_test.go:
--------------------------------------------------------------------------------
1 | package wkhtmltopdf
2 |
3 | import (
4 | "bytes"
5 | "encoding/json"
6 | "io"
7 | "os"
8 | "reflect"
9 | "testing"
10 |
11 | "github.com/stretchr/testify/assert"
12 | )
13 |
14 | func TestPDFGenerator_ToJSON(t *testing.T) {
15 | pdfg := newTestPDFGenerator(t)
16 |
17 | // add a reader page as well
18 | htmlfile, err := os.Open("testdata/htmlsimple.html")
19 | if err != nil {
20 | t.Fatal(err)
21 | }
22 | defer htmlfile.Close()
23 |
24 | pdfg.AddPage(NewPageReader(htmlfile))
25 |
26 | jb, err := pdfg.ToJSON()
27 | if err != nil {
28 | t.Fatal(err)
29 | }
30 |
31 | expected, err := os.ReadFile("testdata/expected.json")
32 | if err != nil {
33 | t.Fatal(err)
34 | }
35 |
36 | assert.JSONEq(t, string(expected), string(jb))
37 | }
38 |
39 | func TestNewPDFGeneratorFromJSON(t *testing.T) {
40 | pdfg := newTestPDFGenerator(t)
41 | jb, err := pdfg.ToJSON()
42 | if err != nil {
43 | t.Fatal(err)
44 | }
45 |
46 | pdfgFromJSON, err := NewPDFGeneratorFromJSON(bytes.NewReader(jb))
47 | if err != nil {
48 | t.Fatal(err)
49 | }
50 |
51 | assert.Equal(t, expectedArgString(), pdfgFromJSON.ArgString())
52 |
53 | pdfgFromJSON.OutputFile = "testdata/TestNewPDFGeneratorFromJSON.PDF"
54 |
55 | err = pdfgFromJSON.Create()
56 | if err != nil {
57 | t.Fatal(err)
58 | }
59 |
60 | }
61 |
62 | func TestNewPDFGeneratorFromJSONWithReader(t *testing.T) {
63 |
64 | pdfg := NewPDFPreparer()
65 | htmlfile, err := os.ReadFile("testdata/htmlsimple.html")
66 | if err != nil {
67 | t.Fatal(err)
68 | }
69 | pdfg.AddPage(NewPageReader(bytes.NewReader(htmlfile)))
70 |
71 | jb, err := pdfg.ToJSON()
72 | if err != nil {
73 | t.Fatal(err)
74 | }
75 |
76 | pdfgFromJSON, err := NewPDFGeneratorFromJSON(bytes.NewReader(jb))
77 | if err != nil {
78 | t.Fatal(err)
79 | }
80 |
81 | // assert argstring
82 | if pdfg.ArgString() != pdfgFromJSON.ArgString() {
83 | t.Errorf("Want argstring:\n%s\nHave:\n%s", pdfg.ArgString(), pdfgFromJSON.ArgString())
84 | }
85 |
86 | // assert content
87 | buf, err := io.ReadAll(pdfgFromJSON.pages[0].Reader())
88 | if err != nil {
89 | t.Fatal(err)
90 | }
91 | if string(buf) != string(htmlfile) {
92 | t.Errorf("Want HTML:\n%s\nHave:\n%s", string(htmlfile), string(buf))
93 | }
94 |
95 | }
96 |
97 | func TestBoolOption_JSON(t *testing.T) {
98 | bo := &boolOption{"option", true}
99 | assertJSON(t, bo, new(boolOption))
100 | }
101 |
102 | func TestFloatOptionJSON(t *testing.T) {
103 | fo := &floatOption{"option", 1.11, true}
104 | assertJSON(t, fo, new(floatOption))
105 | }
106 |
107 | func TestMapOption_JSON(t *testing.T) {
108 | mo := &mapOption{"option", map[string]string{"foo1": "bar1", "foo2": "bar2"}}
109 | assertJSON(t, mo, new(mapOption))
110 | }
111 |
112 | func TestUintOption_JSON(t *testing.T) {
113 | uo := &uintOption{"option", 111, true}
114 | assertJSON(t, uo, new(uintOption))
115 | }
116 |
117 | func TestStringOption_JSON(t *testing.T) {
118 | so := &stringOption{"option", "abc"}
119 | assertJSON(t, so, new(stringOption))
120 | }
121 |
122 | func TestSliceOption_JSON(t *testing.T) {
123 | so := &sliceOption{"option", []string{"foo", "bar"}}
124 | assertJSON(t, so, new(sliceOption))
125 | }
126 |
127 | func assertJSON(t *testing.T, option, newOption interface{}) {
128 | j, err := json.Marshal(option)
129 | if err != nil {
130 | t.Error(err)
131 | }
132 | err = json.Unmarshal(j, newOption)
133 | if err != nil {
134 | t.Error(err)
135 | }
136 | if !reflect.DeepEqual(option, newOption) {
137 | t.Errorf("Diff after marshal and unmarshal:\n%+v\n%+v", option, newOption)
138 | }
139 | }
140 |
--------------------------------------------------------------------------------
/release_test.go:
--------------------------------------------------------------------------------
1 | package wkhtmltopdf
2 |
3 | import (
4 | "reflect"
5 | "regexp"
6 | "strings"
7 | "testing"
8 | )
9 |
10 | // flags which are defaults are not present in the code
11 | var ignoredFlags = []string{
12 | "top",
13 | "enable-javascript",
14 | "background",
15 | "no-debug-javascript",
16 | "enable-external-links",
17 | "outline",
18 | "disable-toc-back-links",
19 | "no-footer-line",
20 | "no-header-line",
21 | "no-print-media-type",
22 | "include-in-outline",
23 | "enable-smart-shrinking",
24 | "resolve-relative-links",
25 | "collate",
26 | "disable-forms",
27 | "disable-plugins",
28 | "stop-slow-scripts",
29 | "images",
30 | "enable-internal-links",
31 | }
32 |
33 | // TestIfArgsAreIncluded checks if all args in the help output of wkhtmltopdf are present in the code.
34 | // If checks if the arguments are in any option set, it currently is not smart enough to check if they are
35 | // in the correct options set (like TOC options, page options etc.).
36 | // This test is skipped by default.
37 | func TestIfArgsAreIncluded(t *testing.T) {
38 | t.SkipNow() // remove if you want to run this test
39 |
40 | // run wkhtmltopdf with extended-help argument
41 | wkpdf, err := NewPDFGenerator()
42 | if err != nil {
43 | t.Fatal(err)
44 | }
45 | wkpdf.ExtendedHelp.Set(true)
46 |
47 | err = wkpdf.Create()
48 | if err != nil {
49 | t.Fatal(err)
50 | }
51 |
52 | // cut off the buffer after "Page sizes:', this is where the arguments end
53 | bufStr := wkpdf.Buffer().String()
54 | bufStr = bufStr[:strings.Index(bufStr, "Page sizes:")]
55 |
56 | // use simple regex to get all long arument flags
57 | argRegex, err := regexp.Compile(`--[a-z-]+\s`)
58 | if err != nil {
59 | t.Fatal(err)
60 | }
61 | helpFlags := argRegex.FindAllString(bufStr, -1)
62 |
63 | // put the flags in a map to remove duplicates
64 | mHelpFlags := make(map[string]bool)
65 | for _, flag := range helpFlags {
66 | mHelpFlags[strings.TrimSpace(strings.TrimPrefix(flag, "--"))] = true
67 | }
68 | t.Logf("found %d arguments in extended help", len(mHelpFlags))
69 |
70 | var unusedFlags []string
71 |
72 | // for each option, check if it is in the code
73 | global := newGlobalOptions()
74 | headerFooter := newHeaderAndFooterOptions()
75 | outline := newOutlineOptions()
76 | page := newPageOptions()
77 | toc := newTocOptions()
78 | for flag, _ := range mHelpFlags {
79 | // check if flag is ignored
80 | ignored := false
81 | for _, ignoredFlag := range ignoredFlags {
82 | if flag == ignoredFlag {
83 | ignored = true
84 | continue
85 | }
86 | }
87 | if ignored {
88 | continue
89 | }
90 |
91 | // check if flag is present
92 | found := false
93 | found = optionsHaveArg(global, flag)
94 | if !found {
95 | found = optionsHaveArg(headerFooter, flag)
96 | }
97 | if !found {
98 | found = optionsHaveArg(outline, flag)
99 | }
100 | if !found {
101 | found = optionsHaveArg(page, flag)
102 | }
103 | if !found {
104 | found = optionsHaveArg(toc, flag)
105 | }
106 | if !found {
107 | unusedFlags = append(unusedFlags, flag)
108 | }
109 | }
110 |
111 | if len(unusedFlags) > 0 {
112 | t.Errorf("%d unused flags:\n%s", len(unusedFlags), strings.Join(unusedFlags, "\n"))
113 | }
114 | }
115 |
116 | func optionsHaveArg(opts interface{}, arg string) bool {
117 | rv := reflect.Indirect(reflect.ValueOf(opts))
118 | if rv.Kind() != reflect.Struct {
119 | return false
120 | }
121 | for i := 0; i < rv.NumField(); i++ {
122 | optionField := rv.Field(i).FieldByName("option")
123 | if optionField.IsZero() {
124 | continue
125 | }
126 | if optionField.String() == arg {
127 | return true
128 | }
129 | }
130 | return false
131 | }
132 |
--------------------------------------------------------------------------------
/json.go:
--------------------------------------------------------------------------------
1 | package wkhtmltopdf
2 |
3 | import (
4 | "bytes"
5 | "encoding/base64"
6 | "encoding/json"
7 | "fmt"
8 | "io"
9 | )
10 |
11 | type jsonPDFGenerator struct {
12 | GlobalOptions globalOptions
13 | OutlineOptions outlineOptions
14 | Cover cover
15 | TOC toc
16 | Pages []jsonPage
17 | }
18 |
19 | type jsonPage struct {
20 | PageOptions PageOptions
21 | InputFile string
22 | Base64PageData string
23 | }
24 |
25 | // ToJSON creates JSON of the complete representation of the PDFGenerator.
26 | // It also saves all pages. For a PageReader page, the content is stored as a Base64 string in the JSON.
27 | func (pdfg *PDFGenerator) ToJSON() ([]byte, error) {
28 |
29 | jpdf := &jsonPDFGenerator{
30 | TOC: pdfg.TOC,
31 | Cover: pdfg.Cover,
32 | GlobalOptions: pdfg.globalOptions,
33 | OutlineOptions: pdfg.outlineOptions,
34 | }
35 |
36 | for _, p := range pdfg.pages {
37 | jp := jsonPage{
38 | InputFile: p.InputFile(),
39 | }
40 | switch tp := p.(type) {
41 | case *Page:
42 | jp.PageOptions = tp.PageOptions
43 | case *PageReader:
44 | jp.PageOptions = tp.PageOptions
45 | }
46 | if p.Reader() != nil {
47 | buf, err := io.ReadAll(p.Reader())
48 | if err != nil {
49 | return nil, err
50 | }
51 | jp.Base64PageData = base64.StdEncoding.EncodeToString(buf)
52 | }
53 | jpdf.Pages = append(jpdf.Pages, jp)
54 | }
55 | return json.Marshal(jpdf)
56 | }
57 |
58 | // NewPDFGeneratorFromJSON creates a new PDFGenerator and restores all the settings and pages
59 | // from a JSON byte slice which should be created using PDFGenerator.ToJSON().
60 | func NewPDFGeneratorFromJSON(jsonReader io.Reader) (*PDFGenerator, error) {
61 |
62 | jp := new(jsonPDFGenerator)
63 |
64 | err := json.NewDecoder(jsonReader).Decode(jp)
65 | if err != nil {
66 | return nil, fmt.Errorf("error unmarshaling JSON: %s", err)
67 | }
68 |
69 | pdfg, err := NewPDFGenerator()
70 | if err != nil {
71 | return nil, fmt.Errorf("error creating PDF generator: %s", err)
72 | }
73 |
74 | pdfg.TOC = jp.TOC
75 | pdfg.Cover = jp.Cover
76 | pdfg.globalOptions = jp.GlobalOptions
77 | pdfg.outlineOptions = jp.OutlineOptions
78 |
79 | for i, p := range jp.Pages {
80 | if p.Base64PageData == "" {
81 | pdfg.AddPage(&Page{
82 | Input: p.InputFile,
83 | PageOptions: p.PageOptions,
84 | })
85 | continue
86 | }
87 | buf, err := base64.StdEncoding.DecodeString(p.Base64PageData)
88 | if err != nil {
89 | return nil, fmt.Errorf("error decoding base 64 input on page %d: %s", i, err)
90 | }
91 | pdfg.AddPage(&PageReader{
92 | Input: bytes.NewReader(buf),
93 | PageOptions: p.PageOptions,
94 | })
95 | }
96 |
97 | return pdfg, nil
98 | }
99 |
100 | type jsonBoolOption struct {
101 | Option string
102 | Value bool
103 | }
104 |
105 | func (bo *boolOption) MarshalJSON() ([]byte, error) {
106 | return json.Marshal(&jsonBoolOption{bo.option, bo.value})
107 | }
108 |
109 | func (bo *boolOption) UnmarshalJSON(b []byte) error {
110 | jbo := new(jsonBoolOption)
111 | err := json.Unmarshal(b, jbo)
112 | if err != nil {
113 | return err
114 | }
115 | bo.value = jbo.Value
116 | bo.option = jbo.Option
117 | return nil
118 | }
119 |
120 | type jsonStringOption struct {
121 | Option string
122 | Value string
123 | }
124 |
125 | func (so *stringOption) MarshalJSON() ([]byte, error) {
126 | return json.Marshal(&jsonStringOption{so.option, so.value})
127 | }
128 |
129 | func (so *stringOption) UnmarshalJSON(b []byte) error {
130 | jso := new(jsonStringOption)
131 | err := json.Unmarshal(b, jso)
132 | if err != nil {
133 | return err
134 | }
135 | so.value = jso.Value
136 | so.option = jso.Option
137 | return nil
138 | }
139 |
140 | type jsonUintOption struct {
141 | Option string
142 | IsSet bool
143 | Value uint
144 | }
145 |
146 | func (io *uintOption) MarshalJSON() ([]byte, error) {
147 | return json.Marshal(&jsonUintOption{io.option, io.isSet, io.value})
148 | }
149 |
150 | func (io *uintOption) UnmarshalJSON(b []byte) error {
151 | jio := new(jsonUintOption)
152 | err := json.Unmarshal(b, jio)
153 | if err != nil {
154 | return err
155 | }
156 | io.value = jio.Value
157 | io.isSet = jio.IsSet
158 | io.option = jio.Option
159 | return nil
160 | }
161 |
162 | type jsonFloatOption struct {
163 | Option string
164 | IsSet bool
165 | Value float64
166 | }
167 |
168 | func (fo *floatOption) MarshalJSON() ([]byte, error) {
169 | return json.Marshal(&jsonFloatOption{fo.option, fo.isSet, fo.value})
170 | }
171 |
172 | func (fo *floatOption) UnmarshalJSON(b []byte) error {
173 | jfo := new(jsonFloatOption)
174 | err := json.Unmarshal(b, jfo)
175 | if err != nil {
176 | return err
177 | }
178 | fo.value = jfo.Value
179 | fo.isSet = jfo.IsSet
180 | fo.option = jfo.Option
181 | return nil
182 | }
183 |
184 | type jsonMapOption struct {
185 | Option string
186 | Value map[string]string
187 | }
188 |
189 | func (mo *mapOption) MarshalJSON() ([]byte, error) {
190 | return json.Marshal(&jsonMapOption{mo.option, mo.value})
191 | }
192 |
193 | func (mo *mapOption) UnmarshalJSON(b []byte) error {
194 | jmo := new(jsonMapOption)
195 | err := json.Unmarshal(b, jmo)
196 | if err != nil {
197 | return err
198 | }
199 | mo.value = jmo.Value
200 | mo.option = jmo.Option
201 | return nil
202 | }
203 |
204 | type jsonSliceOption struct {
205 | Option string
206 | Value []string
207 | }
208 |
209 | func (so *sliceOption) MarshalJSON() ([]byte, error) {
210 | return json.Marshal(&jsonSliceOption{so.option, so.value})
211 | }
212 |
213 | func (so *sliceOption) UnmarshalJSON(b []byte) error {
214 | jso := new(jsonSliceOption)
215 | err := json.Unmarshal(b, jso)
216 | if err != nil {
217 | return err
218 | }
219 | so.value = jso.Value
220 | so.option = jso.Option
221 | return nil
222 | }
223 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | [](https://pkg.go.dev/github.com/SebastiaanKlippert/go-wkhtmltopdf)
2 | [](https://goreportcard.com/report/SebastiaanKlippert/go-wkhtmltopdf)
3 | [](https://codecov.io/gh/SebastiaanKlippert/go-wkhtmltopdf)
4 |
5 | [](https://github.com/SebastiaanKlippert/go-wkhtmltopdf/actions/workflows/ubuntu.yml)
6 | [](https://github.com/SebastiaanKlippert/go-wkhtmltopdf/actions/workflows/macos.yml)
7 |
8 | # go-wkhtmltopdf
9 | Golang commandline wrapper for wkhtmltopdf
10 |
11 | See http://wkhtmltopdf.org/index.html for wkhtmltopdf docs.
12 |
13 | | :warning: WARNING |
14 | |:---------------------------|
15 | | wkhtmltopdf is no longer maintained and now archived on GitHub. See https://wkhtmltopdf.org/status.html |
16 | | This go package is still maintained and will be for a while, but I recommend looking for alternatives for new projects. |
17 |
18 |
19 | # What and why
20 | We needed a way to generate PDF documents from Go. These vary from invoices with highly customizable lay-outs to reports with tables, graphs and images. In our opinion the best way to do this was by using HTML/CSS templates as source for our PDFs. Using CSS print media types and millimeters instead of pixel units we can generate very acurate PDF documents using wkhtmltopdf.
21 |
22 | go-wkhtmltopdf is a pure Golang wrapper around the wkhtmltopdf command line utility.
23 |
24 | It has all options typed out as struct members which makes it very easy to use if you use an IDE with
25 | code completion and it has type safety for all options.
26 | For example you can set general options like
27 | ```go
28 | pdfg.Dpi.Set(600)
29 | pdfg.NoCollate.Set(false)
30 | pdfg.PageSize.Set(PageSizeA4)
31 | pdfg.MarginBottom.Set(40)
32 | ```
33 | The same goes for adding pages, settings page options, TOC options per page etc.
34 |
35 | It takes care of setting the correct order of options as these can become very long with muliple pages where
36 | you have page and TOC options for each page.
37 |
38 | Secondly it makes usage in server-type applications easier, every instance (PDF process) has its own output buffer
39 | which contains the PDF output and you can feed one input document from an io.Reader (using stdin in wkhtmltopdf).
40 | You can combine any number of external HTML documents (HTTP(S) links) with at most one HTML document from stdin and set
41 | options for each input document.
42 |
43 | Note: You can also ignore the internal buffer and let wkhtmltopdf write directly to disk if required for large files, or use the [SetOutput](https://godoc.org/github.com/SebastiaanKlippert/go-wkhtmltopdf#PDFGenerator.SetOutput) method to pass any `io.Writer`.
44 |
45 | For us this is one of the easiest ways to generate PDF documents from Go(lang) and performance is very acceptable.
46 |
47 | # Installation
48 | go get or use a Go dependency manager of your liking.
49 |
50 | ```
51 | go get -u github.com/SebastiaanKlippert/go-wkhtmltopdf
52 | ```
53 |
54 | go-wkhtmltopdf finds the path to wkhtmltopdf by
55 | * first looking in the current dir
56 | * looking in the PATH and PATHEXT environment dirs
57 | * using the WKHTMLTOPDF_PATH environment dir
58 |
59 | **Warning**: Running executables from the current path is no longer possible in Go 1.19, see https://pkg.go.dev/os/exec@master#hdr-Executables_in_the_current_directory
60 |
61 | If you need to set your own wkhtmltopdf path or want to change it during execution, you can call SetPath().
62 |
63 | # Usage
64 | See testfile ```wkhtmltopdf_test.go``` for more complex options, a common use case test is in ```simplesample_test.go```
65 |
66 | ```go
67 | package wkhtmltopdf
68 |
69 | import (
70 | "fmt"
71 | "log"
72 | )
73 |
74 | func ExampleNewPDFGenerator() {
75 |
76 | // Create new PDF generator
77 | pdfg, err := NewPDFGenerator()
78 | if err != nil {
79 | log.Fatal(err)
80 | }
81 |
82 | // Set global options
83 | pdfg.Dpi.Set(300)
84 | pdfg.Orientation.Set(OrientationLandscape)
85 | pdfg.Grayscale.Set(true)
86 |
87 | // Create a new input page from an URL
88 | page := NewPage("https://godoc.org/github.com/SebastiaanKlippert/go-wkhtmltopdf")
89 |
90 | // Set options for this page
91 | page.FooterRight.Set("[page]")
92 | page.FooterFontSize.Set(10)
93 | page.Zoom.Set(0.95)
94 |
95 | // Add to document
96 | pdfg.AddPage(page)
97 |
98 | // Create PDF document in internal buffer
99 | err = pdfg.Create()
100 | if err != nil {
101 | log.Fatal(err)
102 | }
103 |
104 | // Write buffer contents to file on disk
105 | err = pdfg.WriteFile("./simplesample.pdf")
106 | if err != nil {
107 | log.Fatal(err)
108 | }
109 |
110 | fmt.Println("Done")
111 | // Output: Done
112 | }
113 | ```
114 |
115 | As mentioned before, you can provide one document from stdin, this is done by using a [PageReader](https://godoc.org/github.com/SebastiaanKlippert/go-wkhtmltopdf#PageReader "GoDoc") object as input to AddPage. This is best constructed with [NewPageReader](https://godoc.org/github.com/SebastiaanKlippert/go-wkhtmltopdf#NewPageReader "GoDoc") and will accept any io.Reader so this can be used with files from disk (os.File) or memory (bytes.Buffer) etc.
116 | A simple example snippet:
117 | ```go
118 | html := "Hi"
119 | pdfgen.AddPage(NewPageReader(strings.NewReader(html)))
120 | ```
121 |
122 | # Saving to and loading from JSON
123 |
124 | The package now has the possibility to save the PDF Generator object as JSON and to create
125 | a new PDF Generator from a JSON file.
126 | All options and pages are saved in JSON, pages added using NewPageReader are read to memory before saving and then saved as Base64 encoded strings
127 | in the JSON file.
128 |
129 | This is useful to prepare a PDF file and generate the actual PDF elsewhere, for example on AWS Lambda.
130 | To create PDF Generator on the client, where wkhtmltopdf might not be present, function `NewPDFPreparer` can be used.
131 |
132 | Use `NewPDFPreparer` to create a PDF Generator object on the client and `NewPDFGeneratorFromJSON` to reconstruct it on the server.
133 |
134 | ```go
135 | // Client code
136 | pdfg := NewPDFPreparer()
137 | htmlfile, err := ioutil.ReadFile("testdata/htmlsimple.html")
138 | if err != nil {
139 | log.Fatal(err)
140 | }
141 |
142 | pdfg.AddPage(NewPageReader(bytes.NewReader(htmlfile)))
143 | pdfg.Dpi.Set(600)
144 |
145 | // The contents of htmlsimple.html are saved as base64 string in the JSON file
146 | jb, err := pdfg.ToJSON()
147 | if err != nil {
148 | log.Fatal(err)
149 | }
150 |
151 | // Server code
152 | pdfgFromJSON, err := NewPDFGeneratorFromJSON(bytes.NewReader(jb))
153 | if err != nil {
154 | log.Fatal(err)
155 | }
156 |
157 | err = pdfgFromJSON.Create()
158 | if err != nil {
159 | log.Fatal(err)
160 | }
161 | ```
162 |
163 | For an example of running this in AWS Lambda see https://github.com/SebastiaanKlippert/go-wkhtmltopdf-lambda
164 |
165 | # Speed
166 | The speed if pretty much determined by wkhtmltopdf itself, or if you use external source URLs, the time it takes to get and render the source HTML.
167 |
168 | The go wrapper time is negligible with around 0.04ms for parsing an above average number of commandline options.
169 |
170 | Benchmarks are included.
171 |
--------------------------------------------------------------------------------
/wkhtmltopdf.go:
--------------------------------------------------------------------------------
1 | // Package wkhtmltopdf contains wrappers around the wkhtmltopdf commandline tool
2 | package wkhtmltopdf
3 |
4 | import (
5 | "bytes"
6 | "context"
7 | "errors"
8 | "fmt"
9 | "io"
10 | "os"
11 | "os/exec"
12 | "path/filepath"
13 | "strings"
14 | "sync"
15 | )
16 |
17 | // the cached mutexed path as used by findPath()
18 | type stringStore struct {
19 | val string
20 | sync.Mutex
21 | }
22 |
23 | func (ss *stringStore) Get() string {
24 | ss.Lock()
25 | defer ss.Unlock()
26 | return ss.val
27 | }
28 |
29 | func (ss *stringStore) Set(s string) {
30 | ss.Lock()
31 | ss.val = s
32 | ss.Unlock()
33 | }
34 |
35 | var binPath stringStore
36 |
37 | // SetPath sets the path to wkhtmltopdf
38 | func SetPath(path string) {
39 | binPath.Set(path)
40 | }
41 |
42 | // GetPath gets the path to wkhtmltopdf
43 | func GetPath() string {
44 | return binPath.Get()
45 | }
46 |
47 | // Page is the input struct for each page
48 | type Page struct {
49 | Input string
50 | PageOptions
51 | }
52 |
53 | // InputFile returns the input string and is part of the page interface
54 | func (p *Page) InputFile() string {
55 | return p.Input
56 | }
57 |
58 | // Args returns the argument slice and is part of the page interface
59 | func (p *Page) Args() []string {
60 | return p.PageOptions.Args()
61 | }
62 |
63 | // Reader returns the io.Reader and is part of the page interface
64 | func (p *Page) Reader() io.Reader {
65 | return nil
66 | }
67 |
68 | // NewPage creates a new input page from a local or web resource (filepath or URL)
69 | func NewPage(input string) *Page {
70 | return &Page{
71 | Input: input,
72 | PageOptions: NewPageOptions(),
73 | }
74 | }
75 |
76 | // PageReader is one input page (a HTML document) that is read from an io.Reader
77 | // You can add only one Page from a reader
78 | type PageReader struct {
79 | Input io.Reader
80 | PageOptions
81 | }
82 |
83 | // InputFile returns the input string and is part of the page interface
84 | func (pr *PageReader) InputFile() string {
85 | return "-"
86 | }
87 |
88 | // Args returns the argument slice and is part of the page interface
89 | func (pr *PageReader) Args() []string {
90 | return pr.PageOptions.Args()
91 | }
92 |
93 | // Reader returns the io.Reader and is part of the page interface
94 | func (pr *PageReader) Reader() io.Reader {
95 | return pr.Input
96 | }
97 |
98 | // NewPageReader creates a new PageReader from an io.Reader
99 | func NewPageReader(input io.Reader) *PageReader {
100 | return &PageReader{
101 | Input: input,
102 | PageOptions: NewPageOptions(),
103 | }
104 | }
105 |
106 | // PageProvider is the interface which provides a single input page.
107 | // Implemented by Page and PageReader.
108 | type PageProvider interface {
109 | Args() []string
110 | InputFile() string
111 | Reader() io.Reader
112 | }
113 |
114 | // PageOptions are options for each input page
115 | type PageOptions struct {
116 | pageOptions
117 | headerAndFooterOptions
118 | }
119 |
120 | // Args returns the argument slice
121 | func (po *PageOptions) Args() []string {
122 | return append(append([]string{}, po.pageOptions.Args()...), po.headerAndFooterOptions.Args()...)
123 | }
124 |
125 | // NewPageOptions returns a new PageOptions struct with all options
126 | func NewPageOptions() PageOptions {
127 | return PageOptions{
128 | pageOptions: newPageOptions(),
129 | headerAndFooterOptions: newHeaderAndFooterOptions(),
130 | }
131 | }
132 |
133 | // cover page
134 | type cover struct {
135 | Input string
136 | pageOptions
137 | }
138 |
139 | // table of contents
140 | type toc struct {
141 | Include bool
142 | allTocOptions
143 | }
144 |
145 | type allTocOptions struct {
146 | pageOptions
147 | tocOptions
148 | headerAndFooterOptions
149 | }
150 |
151 | // PDFGenerator is the main wkhtmltopdf struct, always use NewPDFGenerator to obtain a new PDFGenerator struct
152 | type PDFGenerator struct {
153 | globalOptions
154 | outlineOptions
155 |
156 | Cover cover
157 | TOC toc
158 | OutputFile string //filename to write to, default empty (writes to internal buffer)
159 |
160 | binPath string
161 | outbuf bytes.Buffer
162 | outWriter io.Writer
163 | stdErr io.Writer
164 | pages []PageProvider
165 | }
166 |
167 | // Args returns the commandline arguments as a string slice
168 | func (pdfg *PDFGenerator) Args() []string {
169 | args := append([]string{}, pdfg.globalOptions.Args()...)
170 | args = append(args, pdfg.outlineOptions.Args()...)
171 | if pdfg.Cover.Input != "" {
172 | args = append(args, "cover")
173 | args = append(args, pdfg.Cover.Input)
174 | args = append(args, pdfg.Cover.pageOptions.Args()...)
175 | }
176 | if pdfg.TOC.Include {
177 | args = append(args, "toc")
178 | args = append(args, pdfg.TOC.pageOptions.Args()...)
179 | args = append(args, pdfg.TOC.tocOptions.Args()...)
180 | args = append(args, pdfg.TOC.headerAndFooterOptions.Args()...)
181 | }
182 | for _, page := range pdfg.pages {
183 | args = append(args, "page")
184 | args = append(args, page.InputFile())
185 | args = append(args, page.Args()...)
186 | }
187 | if pdfg.OutputFile != "" {
188 | args = append(args, pdfg.OutputFile)
189 | } else {
190 | args = append(args, "-")
191 | }
192 | return args
193 | }
194 |
195 | // ArgString returns Args as a single string
196 | func (pdfg *PDFGenerator) ArgString() string {
197 | return strings.Join(pdfg.Args(), " ")
198 | }
199 |
200 | // AddPage adds a new input page to the document.
201 | // A page is an input HTML page, it can span multiple pages in the output document.
202 | // It is a Page when read from file or URL or a PageReader when read from memory.
203 | func (pdfg *PDFGenerator) AddPage(p PageProvider) {
204 | pdfg.pages = append(pdfg.pages, p)
205 | }
206 |
207 | // SetPages resets all pages
208 | func (pdfg *PDFGenerator) SetPages(p []PageProvider) {
209 | pdfg.pages = p
210 | }
211 |
212 | // ResetPages drops all pages previously added by AddPage or SetPages.
213 | // This allows reuse of current instance of PDFGenerator with all of it's configuration preserved.
214 | func (pdfg *PDFGenerator) ResetPages() {
215 | pdfg.pages = []PageProvider{}
216 | }
217 |
218 | // Buffer returns the embedded output buffer used if OutputFile is empty
219 | func (pdfg *PDFGenerator) Buffer() *bytes.Buffer {
220 | return &pdfg.outbuf
221 | }
222 |
223 | // Bytes returns the output byte slice from the output buffer used if OutputFile is empty
224 | func (pdfg *PDFGenerator) Bytes() []byte {
225 | return pdfg.outbuf.Bytes()
226 | }
227 |
228 | // SetOutput sets the output to write the PDF to, when this method is called, the internal buffer will not be used,
229 | // so the Bytes(), Buffer() and WriteFile() methods will not work.
230 | func (pdfg *PDFGenerator) SetOutput(w io.Writer) {
231 | pdfg.outWriter = w
232 | }
233 |
234 | // SetStderr sets the output writer for Stderr when running the wkhtmltopdf command. You only need to call this when you
235 | // want to print the output of wkhtmltopdf (like the progress messages in verbose mode). If not called, or if w is nil, the
236 | // output of Stderr is kept in an internal buffer and returned as error message if there was an error when calling wkhtmltopdf.
237 | func (pdfg *PDFGenerator) SetStderr(w io.Writer) {
238 | pdfg.stdErr = w
239 | }
240 |
241 | // WriteFile writes the contents of the output buffer to a file
242 | func (pdfg *PDFGenerator) WriteFile(filename string) error {
243 | return os.WriteFile(filename, pdfg.Bytes(), 0666)
244 | }
245 |
246 | var lookPath = exec.LookPath
247 |
248 | // findPath finds the path to wkhtmltopdf by
249 | // - first looking in the current dir
250 | // - looking in the PATH and PATHEXT environment dirs
251 | // - using the WKHTMLTOPDF_PATH environment dir
252 | // Warning: Running executables from the current path is no longer possible in Go 1.19
253 | // See https://pkg.go.dev/os/exec@master#hdr-Executables_in_the_current_directory
254 | // The path is cached, meaning you can not change the location of wkhtmltopdf in
255 | // a running program once it has been found
256 | func (pdfg *PDFGenerator) findPath() error {
257 | const exe = "wkhtmltopdf"
258 | pdfg.binPath = GetPath()
259 | if pdfg.binPath != "" {
260 | // wkhtmltopdf has already been found, return
261 | return nil
262 | }
263 | exeDir, err := filepath.Abs(filepath.Dir(os.Args[0]))
264 | if err != nil {
265 | return err
266 | }
267 | path, err := lookPath(filepath.Join(exeDir, exe))
268 | if err == nil && path != "" {
269 | binPath.Set(path)
270 | pdfg.binPath = path
271 | return nil
272 | }
273 | path, err = lookPath(exe)
274 | if errors.Is(err, exec.ErrDot) {
275 | return err
276 | }
277 | if err == nil && path != "" {
278 | binPath.Set(path)
279 | pdfg.binPath = path
280 | return nil
281 | }
282 | dir := os.Getenv("WKHTMLTOPDF_PATH")
283 | if dir == "" {
284 | return fmt.Errorf("%s not found", exe)
285 | }
286 | path, err = lookPath(filepath.Join(dir, exe))
287 | if errors.Is(err, exec.ErrDot) {
288 | return err
289 | }
290 | if err == nil && path != "" {
291 | binPath.Set(path)
292 | pdfg.binPath = path
293 | return nil
294 | }
295 | return fmt.Errorf("%s not found", exe)
296 | }
297 |
298 | func (pdfg *PDFGenerator) checkDuplicateFlags() error {
299 | // we currently can only have duplicates in the global options, so we only check these
300 | var options []string
301 | for _, arg := range pdfg.globalOptions.Args() {
302 | if strings.HasPrefix(arg, "--") { // this is not ideal, the value could also have this prefix
303 | for _, option := range options {
304 | if option == arg {
305 | return fmt.Errorf("duplicate argument: %s", arg)
306 | }
307 | }
308 | options = append(options, arg)
309 | }
310 | }
311 | return nil
312 | }
313 |
314 | // Create creates the PDF document and stores it in the internal buffer if no error is returned
315 | func (pdfg *PDFGenerator) Create() error {
316 | return pdfg.run(context.Background())
317 | }
318 |
319 | // CreateContext is Create with a context passed to exec.CommandContext when calling wkhtmltopdf
320 | func (pdfg *PDFGenerator) CreateContext(ctx context.Context) error {
321 | return pdfg.run(ctx)
322 | }
323 |
324 | func (pdfg *PDFGenerator) run(ctx context.Context) error {
325 | // check for duplicate flags
326 | err := pdfg.checkDuplicateFlags()
327 | if err != nil {
328 | return err
329 | }
330 |
331 | // create command
332 | cmd := exec.CommandContext(ctx, pdfg.binPath, pdfg.Args()...)
333 |
334 | // configure the commande (different for each OS, windows only for now (hides the cmd console))
335 | cmdConfig(cmd)
336 |
337 | // set stderr to the provided writer, or create a new buffer
338 | var errBuf *bytes.Buffer
339 | cmd.Stderr = pdfg.stdErr
340 | if cmd.Stderr == nil {
341 | errBuf = new(bytes.Buffer)
342 | cmd.Stderr = errBuf
343 | }
344 |
345 | // set output to the desired writer or the internal buffer
346 | if pdfg.outWriter != nil {
347 | cmd.Stdout = pdfg.outWriter
348 | } else {
349 | pdfg.outbuf.Reset() // reset internal buffer when we use it
350 | cmd.Stdout = &pdfg.outbuf
351 | }
352 |
353 | // if there is a pageReader page (from Stdin) we set Stdin to that reader
354 | for _, page := range pdfg.pages {
355 | if page.Reader() != nil {
356 | cmd.Stdin = page.Reader()
357 | break
358 | }
359 | }
360 |
361 | // run cmd to create the PDF
362 | err = cmd.Run()
363 | if err != nil {
364 | if ctxErr := ctx.Err(); ctxErr != nil {
365 | return ctxErr
366 | }
367 |
368 | // on an error, return the error and the contents of Stderr if it was our own buffer
369 | // if Stderr was set to a custom writer, just return err
370 | if errBuf != nil {
371 | if errStr := errBuf.String(); strings.TrimSpace(errStr) != "" {
372 | return fmt.Errorf("%s\n%s", errStr, err)
373 | }
374 | }
375 | return err
376 | }
377 | return nil
378 | }
379 |
380 | // NewPDFGenerator returns a new PDFGenerator struct with all options created and
381 | // checks if wkhtmltopdf can be found on the system
382 | func NewPDFGenerator() (*PDFGenerator, error) {
383 | pdfg := NewPDFPreparer()
384 | return pdfg, pdfg.findPath()
385 | }
386 |
387 | // NewPDFPreparer returns a PDFGenerator object without looking for the wkhtmltopdf executable file.
388 | // This is useful to prepare a PDF file that is generated elsewhere and you just want to save the config as JSON.
389 | // Note that Create() can not be called on this object unless you call SetPath yourself.
390 | func NewPDFPreparer() *PDFGenerator {
391 | return &PDFGenerator{
392 | globalOptions: newGlobalOptions(),
393 | outlineOptions: newOutlineOptions(),
394 | Cover: cover{
395 | pageOptions: newPageOptions(),
396 | },
397 | TOC: toc{
398 | allTocOptions: allTocOptions{
399 | tocOptions: newTocOptions(),
400 | pageOptions: newPageOptions(),
401 | headerAndFooterOptions: newHeaderAndFooterOptions(),
402 | },
403 | },
404 | }
405 | }
406 |
--------------------------------------------------------------------------------
/wkhtmltopdf_test.go:
--------------------------------------------------------------------------------
1 | package wkhtmltopdf
2 |
3 | import (
4 | "bytes"
5 | "context"
6 | "errors"
7 | "os"
8 | "os/exec"
9 | "path/filepath"
10 | "reflect"
11 | "runtime"
12 | "strings"
13 | "testing"
14 | "time"
15 |
16 | "github.com/stretchr/testify/assert"
17 | "github.com/stretchr/testify/require"
18 | )
19 |
20 | func newTestPDFGenerator(tb testing.TB) *PDFGenerator {
21 | pdfg, err := NewPDFGenerator()
22 | if err != nil {
23 | tb.Fatal(err)
24 | }
25 |
26 | pdfg.Dpi.Set(600)
27 | pdfg.NoCollate.Set(false)
28 | pdfg.PageSize.Set(PageSizeA4)
29 | pdfg.MarginBottom.Set(40)
30 | pdfg.MarginLeft.Set(0)
31 |
32 | page1 := NewPage("https://www.google.com")
33 |
34 | page1.DisableSmartShrinking.Set(true)
35 | page1.HeaderSpacing.Set(10.01)
36 | page1.Allow.Set("/usr/local/html")
37 | page1.Allow.Set("/usr/local/images")
38 | page1.CustomHeader.Set("X-AppKey", "abcdef")
39 | page1.ViewportSize.Set("3840x2160")
40 | page1.EnableLocalFileAccess.Set(true)
41 |
42 | pdfg.AddPage(page1)
43 |
44 | pdfg.Cover.Input = "https://wkhtmltopdf.org/index.html"
45 | pdfg.Cover.Zoom.Set(0.75)
46 |
47 | pdfg.TOC.Include = true
48 | pdfg.TOC.DisableDottedLines.Set(true)
49 |
50 | return pdfg
51 | }
52 |
53 | func expectedArgString() string {
54 | return "--dpi 600 --margin-bottom 40 --margin-left 0 --page-size A4 cover https://wkhtmltopdf.org/index.html --zoom 0.750 toc --disable-dotted-lines page https://www.google.com --allow /usr/local/html --allow /usr/local/images --custom-header X-AppKey abcdef --disable-smart-shrinking --enable-local-file-access --viewport-size 3840x2160 --header-spacing 10.010 -"
55 | }
56 |
57 | func TestArgString(t *testing.T) {
58 | pdfg := newTestPDFGenerator(t)
59 | assert.Equal(t, expectedArgString(), pdfg.ArgString())
60 |
61 | pdfg.SetPages(pdfg.pages)
62 | assert.Equal(t, expectedArgString(), pdfg.ArgString())
63 | }
64 |
65 | func TestResetPages(t *testing.T) {
66 | //Use a new blank PDF generator
67 | pdfg, err := NewPDFGenerator()
68 | if err != nil {
69 | t.Fatal(err)
70 | }
71 |
72 | // Add 2 pages
73 | pdfg.AddPage(NewPage("https://www.google.com"))
74 | pdfg.AddPage(NewPage("https://www.github.com"))
75 |
76 | // check that we have two pages
77 | if len(pdfg.pages) != 2 {
78 | t.Errorf("Want 2 pages, have %d", len(pdfg.pages))
79 | }
80 |
81 | // Reset
82 | pdfg.ResetPages()
83 |
84 | // check that we have no pages
85 | if len(pdfg.pages) != 0 {
86 | t.Errorf("Want 0 pages, have %d", len(pdfg.pages))
87 | }
88 | }
89 |
90 | func TestVersion(t *testing.T) {
91 | pdfg, err := NewPDFGenerator()
92 | if err != nil {
93 | t.Fatal(err)
94 | }
95 | pdfg.Version.Set(true)
96 | err = pdfg.Create()
97 | if err != nil {
98 | t.Fatal(err)
99 | }
100 | }
101 |
102 | func TestNoInput(t *testing.T) {
103 | pdfg, err := NewPDFGenerator()
104 | if err != nil {
105 | t.Fatal(err)
106 | }
107 | err = pdfg.Create()
108 | if err == nil {
109 | t.Fatal("Want an error when there is no input, have no error")
110 | }
111 | //TODO temp error check because older versions of wkhtmltopdf return a different error :(
112 | wantErrNew := "You need to specify at least one input file, and exactly one output file"
113 | wantErrOld := "You need to specify atleast one input file, and exactly one output file"
114 | if strings.HasPrefix(err.Error(), wantErrNew) == false && strings.HasPrefix(err.Error(), wantErrOld) == false {
115 | t.Errorf("Want error prefix %s or %s, have %s", wantErrNew, wantErrOld, err.Error())
116 | }
117 | }
118 |
119 | func TestGeneratePDF(t *testing.T) {
120 | pdfg := newTestPDFGenerator(t)
121 | err := pdfg.Create()
122 | require.NoError(t, err)
123 |
124 | err = pdfg.WriteFile("testdata/TestGeneratePDF.pdf")
125 | require.NoError(t, err)
126 |
127 | t.Logf("PDF size %vkB", len(pdfg.Bytes())/1024)
128 | }
129 |
130 | func TestContextCancellation(t *testing.T) {
131 | if os.Getenv("GITHUB_ACTIONS") == "true" && runtime.GOOS == "windows" {
132 | t.Skip("temporarily skipping on Windows Github actions, because it blocks. Most likely on due to WindowStatus being set, need to investigate")
133 | }
134 |
135 | pdfg := newTestPDFGenerator(t)
136 | htmlfile, err := os.ReadFile("testdata/htmlsimple.html")
137 | if err != nil {
138 | t.Fatal(err)
139 | }
140 |
141 | htmlPage := NewPageReader(bytes.NewReader(htmlfile))
142 | // WindowStatus waits for page window status to be set to specified value,
143 | // only then it'd render PDF. In our case, it'd never happen and context
144 | // cancellation should cancel the request.
145 | htmlPage.WindowStatus.Set("dummy-status")
146 | ctx, cancelFunc := context.WithTimeout(context.TODO(), 200*time.Millisecond)
147 | defer cancelFunc()
148 |
149 | pdfg.AddPage(htmlPage)
150 |
151 | errBuf := new(bytes.Buffer)
152 | pdfg.SetStderr(errBuf)
153 | err = pdfg.CreateContext(ctx)
154 | if err == nil || err.Error() != "context deadline exceeded" {
155 | t.Errorf("Error should be `context deadline exceeded` but is `%v`", err)
156 | }
157 | }
158 |
159 | func TestGeneratePdfFromStdinSimple(t *testing.T) {
160 | //Use a new blank PDF generator
161 | pdfg, err := NewPDFGenerator()
162 | if err != nil {
163 | t.Fatal(err)
164 | }
165 | htmlfile, err := os.ReadFile("testdata/htmlsimple.html")
166 | if err != nil {
167 | t.Fatal(err)
168 | }
169 | pdfg.AddPage(NewPageReader(bytes.NewReader(htmlfile)))
170 | err = pdfg.Create()
171 | if err != nil {
172 | t.Fatal(err)
173 | }
174 | err = pdfg.WriteFile("testdata/TestGeneratePdfFromStdinSimple.pdf")
175 | if err != nil {
176 | t.Fatal(err)
177 | }
178 | t.Logf("PDF size %vkB", len(pdfg.Bytes())/1024)
179 | if pdfg.Buffer().Len() != len(pdfg.Bytes()) {
180 | t.Errorf("Buffersize not equal")
181 | }
182 | }
183 |
184 | func TestPDFGeneratorOutputFile(t *testing.T) {
185 | pdfg, err := NewPDFGenerator()
186 | if err != nil {
187 | t.Fatal(err)
188 | }
189 | htmlfile, err := os.Open("testdata/htmlsimple.html")
190 | if err != nil {
191 | t.Fatal(err)
192 | }
193 | defer htmlfile.Close()
194 |
195 | pdfg.OutputFile = "testdata/TestPDFGeneratorOutputFile.pdf"
196 |
197 | pdfg.AddPage(NewPageReader(htmlfile))
198 | err = pdfg.Create()
199 | if err != nil {
200 | t.Fatal(err)
201 | }
202 |
203 | pdfFile, err := os.Open("testdata/TestPDFGeneratorOutputFile.pdf")
204 | if err != nil {
205 | t.Fatal(err)
206 | }
207 | defer pdfFile.Close()
208 |
209 | stat, err := pdfFile.Stat()
210 | if err != nil {
211 | t.Fatal(err)
212 | }
213 | if stat.Size() < 100 {
214 | t.Errorf("generated PDF is size under 100 bytes")
215 | }
216 | }
217 |
218 | func TestGeneratePdfFromStdinHtml5(t *testing.T) {
219 | //Use newTestPDFGenerator and append to page1 and TOC
220 | pdfg := newTestPDFGenerator(t)
221 | htmlfile, err := os.ReadFile("testdata/html5.html")
222 | if err != nil {
223 | t.Fatal(err)
224 | }
225 |
226 | page2 := NewPageReader(bytes.NewReader(htmlfile))
227 | page2.EnableLocalFileAccess.Set(true)
228 | pdfg.AddPage(page2)
229 |
230 | err = pdfg.Create()
231 | if err != nil {
232 | t.Fatal(err)
233 | }
234 | err = pdfg.WriteFile("testdata/TestGeneratePdfFromStdinHtml5.pdf")
235 | if err != nil {
236 | t.Fatal(err)
237 | }
238 | t.Logf("PDF size %vkB", len(pdfg.Bytes())/1024)
239 | }
240 |
241 | func TestSetFooter(t *testing.T) {
242 | pdfg, err := NewPDFGenerator()
243 | if err != nil {
244 | t.Fatal(err)
245 | }
246 |
247 | p1 := NewPage("https://www.google.com")
248 | p1.FooterRight.Set("This is page [page]")
249 | p1.FooterFontSize.Set(10)
250 |
251 | pdfg.AddPage(p1)
252 |
253 | err = pdfg.Create()
254 | if err != nil {
255 | t.Fatal(err)
256 | }
257 | err = pdfg.WriteFile("testdata/TestSetFooter.pdf")
258 | if err != nil {
259 | t.Fatal(err)
260 | }
261 | t.Logf("PDF size %vkB", len(pdfg.Bytes())/1024)
262 | }
263 |
264 | func TestPath(t *testing.T) {
265 | path := "/usr/wkhtmltopdf/wkhtmltopdf"
266 | SetPath(path)
267 | defer SetPath("")
268 | if GetPath() != path {
269 | t.Errorf("Have path %q, want %q", GetPath(), path)
270 | }
271 | }
272 |
273 | func TestPDFGenerator_SetOutput(t *testing.T) {
274 | //Use a new blank PDF generator
275 | pdfg, err := NewPDFGenerator()
276 | if err != nil {
277 | t.Fatal(err)
278 | }
279 |
280 | htmlfile, err := os.Open("testdata/htmlsimple.html")
281 | if err != nil {
282 | t.Fatal(err)
283 | }
284 | defer htmlfile.Close()
285 |
286 | pdfg.AddPage(NewPageReader(htmlfile))
287 |
288 | outBuf := new(bytes.Buffer)
289 | pdfg.SetOutput(outBuf)
290 |
291 | err = pdfg.Create()
292 | if err != nil {
293 | t.Fatal(err)
294 | }
295 |
296 | b := pdfg.Bytes()
297 | if len(b) != 0 {
298 | t.Errorf("expected to have zero bytes in internal buffer, have %d", len(b))
299 | }
300 |
301 | b = outBuf.Bytes()
302 | if len(b) < 3000 {
303 | t.Errorf("expected to have > 3000 bytes in output buffer, have %d", len(b))
304 | }
305 | }
306 |
307 | func TestPDFGenerator_SetStderr(t *testing.T) {
308 | //Use a new blank PDF generator
309 | pdfg, err := NewPDFGenerator()
310 | if err != nil {
311 | t.Fatal(err)
312 | }
313 |
314 | htmlfile, err := os.Open("testdata/htmlsimple.html")
315 | if err != nil {
316 | t.Fatal(err)
317 | }
318 | defer htmlfile.Close()
319 |
320 | pdfg.AddPage(NewPageReader(htmlfile))
321 |
322 | errBuf := new(bytes.Buffer)
323 | pdfg.SetStderr(errBuf)
324 |
325 | err = pdfg.Create()
326 | if err != nil {
327 | t.Fatal(err)
328 | }
329 |
330 | // not sure if this is correct for all versions of wkhtmltopdf and if it is always in English
331 | outputStr := errBuf.String()
332 | shouldContain := []string{"Loading pages", "Printing pages"}
333 | for _, s := range shouldContain {
334 | if strings.Contains(outputStr, s) == false {
335 | t.Errorf("Stderr should contain %q, but it does not", s)
336 | }
337 | }
338 | }
339 |
340 | func TestTOCAndCustomFooter(t *testing.T) {
341 | //Use a new blank PDF generator
342 | pdfg, err := NewPDFGenerator()
343 | if err != nil {
344 | t.Fatal(err)
345 | }
346 |
347 | htmlfile, err := os.Open("testdata/html5.html")
348 | if err != nil {
349 | t.Fatal(err)
350 | }
351 | defer htmlfile.Close()
352 | page := NewPageReader(htmlfile)
353 | page.EnableLocalFileAccess.Set(true) //needed to include js
354 | pdfg.AddPage(page)
355 |
356 | page.FooterHTML.Set("testdata/footer.html")
357 | page.FooterSpacing.Set(8)
358 |
359 | pdfg.TOC.XslStyleSheet.Set("testdata/toc.xls")
360 | pdfg.TOC.Include = true
361 | pdfg.TOC.EnableLocalFileAccess.Set(true) //needed to include js
362 | pdfg.TOC.FooterHTML.Set("testdata/footer-toc.html")
363 | pdfg.TOC.FooterSpacing.Set(8)
364 |
365 | err = pdfg.Create()
366 | if err != nil {
367 | t.Fatal(err)
368 | }
369 |
370 | // Write buffer contents to file on disk
371 | err = pdfg.WriteFile("testdata/TestGeneratePdfTOCAndCustomFooter.pdf")
372 | if err != nil {
373 | t.Fatal(err)
374 | }
375 | }
376 |
377 | func TestUnitOptions(t *testing.T) {
378 | //Use a new blank PDF generator
379 | pdfg, err := NewPDFGenerator()
380 | assert.NoError(t, err)
381 |
382 | // Add a page
383 | pdfg.AddPage(NewPage("https://www.google.com"))
384 |
385 | // Set all unit options
386 | pdfg.MarginRightUnit.Set("1mm")
387 | pdfg.MarginLeftUnit.Set("2cm")
388 | pdfg.MarginBottomUnit.Set("0.5cm")
389 | pdfg.MarginTopUnit.Set("10mm")
390 | pdfg.PageHeightUnit.Set("10in")
391 | pdfg.PageWidthUnit.Set("5.5in")
392 |
393 | want := `--margin-bottom 0.5cm --margin-left 2cm --margin-right 1mm --margin-top 10mm --page-height 10in --page-width 5.5in page https://www.google.com -`
394 | assert.Equal(t, want, pdfg.ArgString())
395 |
396 | err = pdfg.Create()
397 | if err != nil {
398 | t.Fatal(err)
399 | }
400 |
401 | // Write buffer contents to file on disk
402 | err = pdfg.WriteFile("testdata/TestUnitOptions.pdf")
403 | if err != nil {
404 | t.Fatal(err)
405 | }
406 | }
407 |
408 | func TestDuplicateOptions(t *testing.T) {
409 | //Use a new blank PDF generator
410 | pdfg, err := NewPDFGenerator()
411 | assert.NoError(t, err)
412 |
413 | // Add a page
414 | pdfg.AddPage(NewPage("https://www.google.com"))
415 |
416 | // Set a duplicate option (the value can be different)
417 | pdfg.MarginRight.Set(1)
418 | pdfg.MarginRightUnit.Set("1cm")
419 |
420 | err = pdfg.Create()
421 | assert.EqualError(t, err, "duplicate argument: --margin-right")
422 | }
423 |
424 | func TestBufferReset(t *testing.T) {
425 | // Use a new blank PDF generator
426 | pdfg, err := NewPDFGenerator()
427 | if err != nil {
428 | t.Fatal(err)
429 | }
430 |
431 | // Add one page
432 | htmlfile, err := os.ReadFile("testdata/htmlsimple.html")
433 | if err != nil {
434 | t.Fatal(err)
435 | }
436 | pdfg.AddPage(NewPageReader(bytes.NewReader(htmlfile)))
437 |
438 | // Create PDF
439 | err = pdfg.Create()
440 | if err != nil {
441 | t.Fatal(err)
442 | }
443 |
444 | // Test if the internal buffer is not emty
445 | bufSize := pdfg.Buffer().Len()
446 | assert.Greater(t, bufSize, 0)
447 |
448 | // Reset pages and run same Create() again
449 | pdfg.ResetPages()
450 | pdfg.AddPage(NewPageReader(bytes.NewReader(htmlfile)))
451 | err = pdfg.Create()
452 | if err != nil {
453 | t.Fatal(err)
454 | }
455 |
456 | // Test is Buffer Size is equal to size of previous Create()
457 | assert.Equal(t, bufSize, pdfg.Buffer().Len())
458 | }
459 |
460 | func TestFindPath(t *testing.T) {
461 | defer func() { lookPath = exec.LookPath }()
462 |
463 | pdfgen := new(PDFGenerator)
464 |
465 | // lookpath finds a result immediately
466 | lookPath = func(file string) (string, error) {
467 | return file, nil
468 | }
469 |
470 | binPath.Set("")
471 | err := pdfgen.findPath()
472 | assert.NoError(t, err)
473 |
474 | // lookpath only returns a path when called with "wkhtmltopdf"
475 | lookPath = func(file string) (string, error) {
476 | if file == "wkhtmltopdf" {
477 | return file, nil
478 | }
479 | return "", errors.New("mock error")
480 | }
481 |
482 | binPath.Set("")
483 | err = pdfgen.findPath()
484 | assert.NoError(t, err)
485 | assert.Equal(t, "wkhtmltopdf", binPath.Get())
486 |
487 | // lookpath returns exec.ErrDot when called with "wkhtmltopdf"
488 | lookPath = func(file string) (string, error) {
489 | if file == "wkhtmltopdf" {
490 | return "", exec.ErrDot
491 | }
492 | return "", errors.New("mock error")
493 | }
494 |
495 | binPath.Set("")
496 | err = pdfgen.findPath()
497 | assert.Error(t, err)
498 | assert.EqualError(t, err, exec.ErrDot.Error())
499 |
500 | // lookpath only finds a path when "WKHTMLTOPDF_PATH" is included
501 | const WKHTMLTOPDFPATH = "/fake/path"
502 | os.Setenv("WKHTMLTOPDF_PATH", WKHTMLTOPDFPATH)
503 | lookPath = func(file string) (string, error) {
504 | if strings.HasPrefix(file, filepath.Clean(WKHTMLTOPDFPATH)) {
505 | return file, nil
506 | }
507 | return "", errors.New("mock error")
508 | }
509 |
510 | binPath.Set("")
511 | err = pdfgen.findPath()
512 | assert.NoError(t, err)
513 |
514 | // lookpath returns exec.ErrDot when "WKHTMLTOPDF_PATH" is included
515 | lookPath = func(file string) (string, error) {
516 | if strings.HasPrefix(file, filepath.Clean(WKHTMLTOPDFPATH)) {
517 | return "", exec.ErrDot
518 | }
519 | return "", errors.New("mock error")
520 | }
521 |
522 | binPath.Set("")
523 | err = pdfgen.findPath()
524 | assert.Error(t, err)
525 | assert.EqualError(t, err, exec.ErrDot.Error())
526 |
527 | // lookpath always returns an error and WKHTMLTOPDF_PATH is empty
528 | os.Setenv("WKHTMLTOPDF_PATH", "")
529 | lookPath = func(file string) (string, error) {
530 | return "", errors.New("mock error")
531 | }
532 |
533 | binPath.Set("")
534 | err = pdfgen.findPath()
535 | assert.Error(t, err)
536 | assert.EqualError(t, err, "wkhtmltopdf not found")
537 |
538 | // lookpath always returns an error and WKHTMLTOPDF_PATH is NOT empty
539 | os.Setenv("WKHTMLTOPDF_PATH", WKHTMLTOPDFPATH)
540 | lookPath = func(file string) (string, error) {
541 | return "", errors.New("mock error")
542 | }
543 |
544 | binPath.Set("")
545 | err = pdfgen.findPath()
546 | assert.Error(t, err)
547 | assert.EqualError(t, err, "wkhtmltopdf not found")
548 | }
549 |
550 | func TestStringOption(t *testing.T) {
551 | opt := stringOption{
552 | option: "stringopt",
553 | }
554 | opt.Set("value123")
555 |
556 | want := []string{"--stringopt", "value123"}
557 |
558 | if !reflect.DeepEqual(opt.Parse(), want) {
559 | t.Errorf("expected %v, have %v", want, opt.Parse())
560 | }
561 |
562 | opt.Unset()
563 | if !reflect.DeepEqual(opt.Parse(), []string{}) {
564 | t.Errorf("not empty after unset")
565 | }
566 | }
567 |
568 | func TestSliceOption(t *testing.T) {
569 | opt := sliceOption{
570 | option: "sliceopt",
571 | }
572 | opt.Set("string15183")
573 | opt.Set("foo")
574 | opt.Set("bar")
575 |
576 | want := []string{"--sliceopt", "string15183", "--sliceopt", "foo", "--sliceopt", "bar"}
577 |
578 | if !reflect.DeepEqual(opt.Parse(), want) {
579 | t.Errorf("expected %v, have %v", want, opt.Parse())
580 | }
581 |
582 | opt.Unset()
583 | if !reflect.DeepEqual(opt.Parse(), []string{}) {
584 | t.Errorf("not empty after unset")
585 | }
586 | }
587 |
588 | func TestMapOption(t *testing.T) {
589 | opt := mapOption{
590 | option: "mapopt",
591 | }
592 |
593 | opt.Set("key1", "foo")
594 | opt.Set("key2", "bar")
595 | opt.Set("key3", "Hello")
596 |
597 | result := strings.Join(opt.Parse(), " ")
598 | if !strings.Contains(result, "--mapopt key1 foo") {
599 | t.Error("missing map option key1")
600 | }
601 | if !strings.Contains(result, "--mapopt key2 bar") {
602 | t.Error("missing map option key2")
603 | }
604 | if !strings.Contains(result, "--mapopt key3 Hello") {
605 | t.Error("missing map option key3")
606 | }
607 |
608 | opt.Unset()
609 | if !reflect.DeepEqual(opt.Parse(), []string{}) {
610 | t.Errorf("not empty after unset")
611 | }
612 | }
613 |
614 | func TestUIntOption(t *testing.T) {
615 | opt := uintOption{
616 | option: "uintopt",
617 | }
618 | opt.Set(14860)
619 |
620 | want := []string{"--uintopt", "14860"}
621 |
622 | if !reflect.DeepEqual(opt.Parse(), want) {
623 | t.Errorf("expected %v, have %v", want, opt.Parse())
624 | }
625 |
626 | opt.Unset()
627 | if !reflect.DeepEqual(opt.Parse(), []string{}) {
628 | t.Errorf("not empty after unset")
629 | }
630 | }
631 |
632 | func TestFloatOption(t *testing.T) {
633 | opt := floatOption{
634 | option: "flopt",
635 | }
636 | opt.Set(239.75)
637 |
638 | want := []string{"--flopt", "239.750"}
639 |
640 | if !reflect.DeepEqual(opt.Parse(), want) {
641 | t.Errorf("expected %v, have %v", want, opt.Parse())
642 | }
643 |
644 | opt.Unset()
645 | if !reflect.DeepEqual(opt.Parse(), []string{}) {
646 | t.Errorf("not empty after unset")
647 | }
648 | }
649 |
650 | func TestBoolOption(t *testing.T) {
651 | opt := boolOption{
652 | option: "boolopt",
653 | }
654 | opt.Set(true)
655 |
656 | want := []string{"--boolopt"}
657 |
658 | if !reflect.DeepEqual(opt.Parse(), want) {
659 | t.Errorf("expected %v, have %v", want, opt.Parse())
660 | }
661 |
662 | opt.Unset()
663 | if !reflect.DeepEqual(opt.Parse(), []string{}) {
664 | t.Errorf("not empty after unset")
665 | }
666 | }
667 |
668 | func BenchmarkArgs(b *testing.B) {
669 | pdfg := newTestPDFGenerator(b)
670 | b.ResetTimer()
671 | for i := 0; i < b.N; i++ {
672 | pdfg.Args()
673 | }
674 | }
675 |
--------------------------------------------------------------------------------
/options.go:
--------------------------------------------------------------------------------
1 | package wkhtmltopdf
2 |
3 | import (
4 | "fmt"
5 | "reflect"
6 | )
7 |
8 | const opt = "--"
9 |
10 | // A list of options that can be set from code to make it easier to see which options are available
11 | type globalOptions struct {
12 | CookieJar stringOption // Read and write cookies from and to the supplied cookie jar file
13 | Copies uintOption // Number of copies to print into the pdf file (default 1)
14 | Dpi uintOption // Change the dpi explicitly (this has no effect on X11 based systems)
15 | ExtendedHelp boolOption // Display more extensive help, detailing less common command switches
16 | Grayscale boolOption // PDF will be generated in grayscale
17 | Help boolOption // Display help
18 | HTMLDoc boolOption // Output program html help
19 | ImageDpi uintOption // When embedding images scale them down to this dpi (default 600)
20 | ImageQuality uintOption // When jpeg compressing images use this quality (default 94)
21 | License boolOption // Output license information and exit
22 | LogLevel stringOption // Set log level to: none, error, warn or info (default info)
23 | LowQuality boolOption // Generates lower quality pdf/ps. Useful to shrink the result document space
24 | ManPage boolOption // Output program man page
25 | MarginBottom uintOption // Set the page bottom margin in centimeters
26 | MarginBottomUnit stringOption // Set the page bottom margin with a unit
27 | MarginLeft uintOption // Set the page left margin (default 10mm)
28 | MarginLeftUnit stringOption // Set the page left margin with a unit
29 | MarginRight uintOption // Set the page right margin (default 10mm)
30 | MarginRightUnit stringOption // Set the page right margin with a unit
31 | MarginTop uintOption // Set the page top margin
32 | MarginTopUnit stringOption // Set the page top margin with a unit
33 | NoCollate boolOption // Do not collate when printing multiple copies (default collate)
34 | NoPdfCompression boolOption // Do not use lossless compression on pdf objects
35 | Orientation stringOption // Set orientation to Landscape or Portrait (default Portrait)
36 | PageHeight uintOption // Page height
37 | PageHeightUnit stringOption // Page height with a unit
38 | PageSize stringOption // Set paper size to: A4, Letter, etc. (default A4)
39 | PageWidth uintOption // Page width
40 | PageWidthUnit stringOption // Page width with a unit
41 | Quiet boolOption // Be less verbose
42 | ReadArgsFromStdin boolOption // Read command line arguments from stdin
43 | Readme boolOption // Output program readme
44 | Title stringOption // The title of the generated pdf file (The title of the first document is used if not specified)
45 | Version boolOption // Output version information and exit
46 | }
47 |
48 | func (gopt *globalOptions) Args() []string {
49 | return optsToArgs(gopt)
50 | }
51 |
52 | type outlineOptions struct {
53 | DumpDefaultTocXsl boolOption // Dump the default TOC xsl style sheet to stdout
54 | DumpOutline stringOption // Dump the outline to a file
55 | NoOutline boolOption // Do not put an outline into the pdf
56 | OutlineDepth uintOption // Set the depth of the outline (default 4)
57 | }
58 |
59 | func (oopt *outlineOptions) Args() []string {
60 | return optsToArgs(oopt)
61 | }
62 |
63 | type pageOptions struct {
64 | Allow sliceOption // Allow the file or files from the specified folder to be loaded (repeatable)
65 | BypassProxyFor sliceOption // Bypass proxy for host
66 | CacheDir stringOption // Web cache directory
67 | CheckboxCheckedSvg stringOption // Use this SVG file when rendering checked checkboxes
68 | CheckboxSvg stringOption // Use this SVG file when rendering unchecked checkboxes
69 | Cookie mapOption // Set an additional cookie (repeatable), value should be url encoded
70 | CustomHeader mapOption // Set an additional HTTP header (repeatable)
71 | CustomHeaderPropagation boolOption // Add HTTP headers specified by --custom-header for each resource request
72 | DebugJavascript boolOption // Show javascript debugging output
73 | DefaultHeader boolOption // Add a default header, with the name of the page to the left, and the page number to the right, this is short for: --header-left='[webpage]' --header-right='[page]/[toPage]' --top 2cm --header-line
74 | DisableExternalLinks boolOption // Do not make links to remote web pages
75 | DisableInternalLinks boolOption // Do not make local links
76 | DisableJavascript boolOption // Do not allow web pages to run javascript
77 | DisableLocalFileAccess boolOption // Do not allowed conversion of a local file to read in other local files, unless explicitly allowed with --allow
78 | DisableSmartShrinking boolOption // Disable the intelligent shrinking strategy used by WebKit that makes the pixel/dpi ratio none constant
79 | EnableForms boolOption // Turn HTML form fields into pdf form fields
80 | EnableLocalFileAccess boolOption // Allowed conversion of a local file to read in other local files
81 | EnablePlugins boolOption // Enable installed plugins (plugins will likely not work)
82 | EnableTocBackLinks boolOption // Link from section header to toc
83 | Encoding stringOption // Set the default text encoding, for input
84 | ExcludeFromOutline boolOption // Do not include the page in the table of contents and outlines
85 | JavascriptDelay uintOption // Wait some milliseconds for javascript finish (default 200)
86 | KeepRelativeLinks boolOption // Keep relative external links as relative external links
87 | LoadErrorHandling stringOption // Specify how to handle pages that fail to load: abort, ignore or skip (default abort)
88 | LoadMediaErrorHandling stringOption // Specify how to handle media files that fail to load: abort, ignore or skip (default ignore)
89 | MinimumFontSize uintOption // Minimum font size
90 | NoBackground boolOption // Do not print background
91 | NoCustomHeaderPropagation boolOption // Do not add HTTP headers specified by --custom-header for each resource request
92 | NoImages boolOption // Do not load or print images
93 | NoStopSlowScripts boolOption // Do not Stop slow running javascripts
94 | PageOffset uintOption // Set the starting page number (default 0)
95 | Password stringOption // HTTP Authentication password
96 | Post mapOption // Add an additional post field (repeatable)
97 | PostFile mapOption // Post an additional file (repeatable)
98 | PrintMediaType boolOption // Use print media-type instead of screen
99 | Proxy stringOption // Use a proxy
100 | ProxyHostnameLookup boolOption // Use the proxy for resolving hostnames
101 | RadiobuttonCheckedSvg stringOption // Use this SVG file when rendering checked radiobuttons
102 | RadiobuttonSvg stringOption // Use this SVG file when rendering unchecked radiobuttons
103 | RunScript sliceOption // Run this additional javascript after the page is done loading (repeatable)
104 | SslCrtPath stringOption // Path to the ssl client cert public key in OpenSSL PEM format, optionally followed by intermediate ca and trusted certs
105 | SslKeyPassword stringOption // Password to ssl client cert private key
106 | SslKeyPath stringOption // Path to ssl client cert private key in OpenSSL PEM format
107 | Username stringOption // HTTP Authentication username
108 | UserStyleSheet stringOption // Specify a user style sheet, to load with every page
109 | ViewportSize stringOption // Set viewport size if you have custom scrollbars or css attribute overflow to emulate window size
110 | WindowStatus stringOption // Wait until window.status is equal to this string before rendering page
111 | Zoom floatOption // Use this zoom factor (default 1)
112 | }
113 |
114 | func (popt *pageOptions) Args() []string {
115 | return optsToArgs(popt)
116 | }
117 |
118 | type headerAndFooterOptions struct {
119 | FooterCenter stringOption // Centered footer text
120 | FooterFontName stringOption // Set footer font name (default Arial)
121 | FooterFontSize uintOption // Set footer font size (default 12)
122 | FooterHTML stringOption // Adds a html footer
123 | FooterLeft stringOption // Left aligned footer text
124 | FooterLine boolOption // Display line above the footer
125 | FooterRight stringOption // Right aligned footer text
126 | FooterSpacing floatOption // Spacing between footer and content in mm (default 0)
127 | HeaderCenter stringOption // Centered header text
128 | HeaderFontName stringOption // Set header font name (default Arial)
129 | HeaderFontSize uintOption // Set header font size (default 12)
130 | HeaderHTML stringOption // Adds a html header
131 | HeaderLeft stringOption // Left aligned header text
132 | HeaderLine boolOption // Display line below the header
133 | HeaderRight stringOption // Right aligned header text
134 | HeaderSpacing floatOption // Spacing between header and content in mm (default 0)
135 | Replace mapOption // Replace [name] with value in header and footer (repeatable)
136 | }
137 |
138 | func (hopt *headerAndFooterOptions) Args() []string {
139 | return optsToArgs(hopt)
140 | }
141 |
142 | type tocOptions struct {
143 | DisableDottedLines boolOption // Do not use dotted lines in the toc
144 | DisableTocLinks boolOption // Do not link from toc to sections
145 | TocHeaderText stringOption // The header text of the toc (default Table of Contents)
146 | TocLevelIndentation uintOption // For each level of headings in the toc indent by this length (default 1em)
147 | TocTextSizeShrink floatOption // For each level of headings in the toc the font is scaled by this factor
148 | XslStyleSheet stringOption // Use the supplied xsl style sheet for printing the table of content
149 | }
150 |
151 | func (topt *tocOptions) Args() []string {
152 | return optsToArgs(topt)
153 | }
154 |
155 | type argParser interface {
156 | Parse() []string // Used in the cmd call
157 | }
158 |
159 | type stringOption struct {
160 | option string
161 | value string
162 | }
163 |
164 | func (so stringOption) Parse() []string {
165 | args := make([]string, 0)
166 | if so.value == "" {
167 | return args
168 | }
169 | args = append(args, opt+so.option)
170 | args = append(args, so.value)
171 | return args
172 | }
173 |
174 | func (so *stringOption) Set(value string) {
175 | so.value = value
176 | }
177 |
178 | func (so *stringOption) Unset() {
179 | so.value = ""
180 | }
181 |
182 | type sliceOption struct {
183 | option string
184 | value []string
185 | }
186 |
187 | func (so sliceOption) Parse() []string {
188 | args := make([]string, 0)
189 | if len(so.value) == 0 {
190 | return args
191 | }
192 | for _, v := range so.value {
193 | args = append(args, opt+so.option)
194 | args = append(args, v)
195 | }
196 | return args
197 | }
198 |
199 | func (so *sliceOption) Set(value string) {
200 | so.value = append(so.value, value)
201 | }
202 |
203 | func (so *sliceOption) Unset() {
204 | so.value = nil
205 | }
206 |
207 | type mapOption struct {
208 | option string
209 | value map[string]string
210 | }
211 |
212 | func (mo mapOption) Parse() []string {
213 | args := make([]string, 0)
214 | if mo.value == nil || len(mo.value) == 0 {
215 | return args
216 | }
217 | for k, v := range mo.value {
218 | args = append(args, opt+mo.option)
219 | args = append(args, k)
220 | args = append(args, v)
221 | }
222 | return args
223 | }
224 |
225 | func (mo *mapOption) Set(key, value string) {
226 | if mo.value == nil {
227 | mo.value = make(map[string]string)
228 | }
229 | mo.value[key] = value
230 | }
231 |
232 | func (mo *mapOption) Unset() {
233 | mo.value = nil
234 | }
235 |
236 | type uintOption struct {
237 | option string
238 | value uint
239 | isSet bool
240 | }
241 |
242 | func (io uintOption) Parse() []string {
243 | args := make([]string, 0)
244 | if io.isSet == false {
245 | return args
246 | }
247 | args = append(args, opt+io.option)
248 | args = append(args, fmt.Sprintf("%d", io.value))
249 | return args
250 | }
251 |
252 | func (io *uintOption) Set(value uint) {
253 | io.isSet = true
254 | io.value = value
255 | }
256 |
257 | func (io *uintOption) Unset() {
258 | io.isSet = false
259 | }
260 |
261 | type floatOption struct {
262 | option string
263 | value float64
264 | isSet bool
265 | }
266 |
267 | func (fo floatOption) Parse() []string {
268 | args := make([]string, 0)
269 | if fo.isSet == false {
270 | return args
271 | }
272 | args = append(args, opt+fo.option)
273 | args = append(args, fmt.Sprintf("%.3f", fo.value))
274 | return args
275 | }
276 |
277 | func (fo *floatOption) Set(value float64) {
278 | fo.isSet = true
279 | fo.value = value
280 | }
281 |
282 | func (fo *floatOption) Unset() {
283 | fo.isSet = false
284 | }
285 |
286 | type boolOption struct {
287 | option string
288 | value bool
289 | }
290 |
291 | func (bo boolOption) Parse() []string {
292 | if bo.value {
293 | return []string{opt + bo.option}
294 | }
295 | return []string{}
296 | }
297 |
298 | func (bo *boolOption) Set(value bool) {
299 | bo.value = value
300 | }
301 |
302 | func (bo *boolOption) Unset() {
303 | bo.value = false
304 | }
305 |
306 | func newGlobalOptions() globalOptions {
307 | return globalOptions{
308 | CookieJar: stringOption{option: "cookie-jar"},
309 | Copies: uintOption{option: "copies"},
310 | Dpi: uintOption{option: "dpi"},
311 | ExtendedHelp: boolOption{option: "extended-help"},
312 | Grayscale: boolOption{option: "grayscale"},
313 | Help: boolOption{option: "help"},
314 | HTMLDoc: boolOption{option: "htmldoc"},
315 | ImageDpi: uintOption{option: "image-dpi"},
316 | ImageQuality: uintOption{option: "image-quality"},
317 | License: boolOption{option: "license"},
318 | LogLevel: stringOption{option: "log-level"},
319 | LowQuality: boolOption{option: "lowquality"},
320 | ManPage: boolOption{option: "manpage"},
321 | MarginBottom: uintOption{option: "margin-bottom"},
322 | MarginBottomUnit: stringOption{option: "margin-bottom"},
323 | MarginLeft: uintOption{option: "margin-left"},
324 | MarginLeftUnit: stringOption{option: "margin-left"},
325 | MarginRight: uintOption{option: "margin-right"},
326 | MarginRightUnit: stringOption{option: "margin-right"},
327 | MarginTop: uintOption{option: "margin-top"},
328 | MarginTopUnit: stringOption{option: "margin-top"},
329 | NoCollate: boolOption{option: "no-collate"},
330 | NoPdfCompression: boolOption{option: "no-pdf-compression"},
331 | Orientation: stringOption{option: "orientation"},
332 | PageHeight: uintOption{option: "page-height"},
333 | PageHeightUnit: stringOption{option: "page-height"},
334 | PageSize: stringOption{option: "page-size"},
335 | PageWidth: uintOption{option: "page-width"},
336 | PageWidthUnit: stringOption{option: "page-width"},
337 | Quiet: boolOption{option: "quiet"},
338 | ReadArgsFromStdin: boolOption{option: "read-args-from-stdin"},
339 | Readme: boolOption{option: "readme"},
340 | Title: stringOption{option: "title"},
341 | Version: boolOption{option: "version"},
342 | }
343 | }
344 |
345 | func newOutlineOptions() outlineOptions {
346 | return outlineOptions{
347 | DumpDefaultTocXsl: boolOption{option: "dump-default-toc-xsl"},
348 | DumpOutline: stringOption{option: "dump-outline"},
349 | NoOutline: boolOption{option: "no-outline"},
350 | OutlineDepth: uintOption{option: "outline-depth"},
351 | }
352 | }
353 |
354 | func newPageOptions() pageOptions {
355 | return pageOptions{
356 | Allow: sliceOption{option: "allow"},
357 | BypassProxyFor: sliceOption{option: "bypass-proxy-for"},
358 | CacheDir: stringOption{option: "cache-dir"},
359 | CheckboxCheckedSvg: stringOption{option: "checkbox-checked-svg"},
360 | CheckboxSvg: stringOption{option: "checkbox-svg"},
361 | Cookie: mapOption{option: "cookie"},
362 | CustomHeader: mapOption{option: "custom-header"},
363 | CustomHeaderPropagation: boolOption{option: "custom-header-propagation"},
364 | DebugJavascript: boolOption{option: "debug-javascript"},
365 | DefaultHeader: boolOption{option: "default-header"},
366 | DisableExternalLinks: boolOption{option: "disable-external-links"},
367 | DisableInternalLinks: boolOption{option: "disable-internal-links"},
368 | DisableJavascript: boolOption{option: "disable-javascript"},
369 | DisableLocalFileAccess: boolOption{option: "disable-local-file-access"},
370 | DisableSmartShrinking: boolOption{option: "disable-smart-shrinking"},
371 | EnableForms: boolOption{option: "enable-forms"},
372 | EnableLocalFileAccess: boolOption{option: "enable-local-file-access"},
373 | EnablePlugins: boolOption{option: "enable-plugins"},
374 | EnableTocBackLinks: boolOption{option: "enable-toc-back-links"},
375 | Encoding: stringOption{option: "encoding"},
376 | ExcludeFromOutline: boolOption{option: "exclude-from-outline"},
377 | JavascriptDelay: uintOption{option: "javascript-delay"},
378 | KeepRelativeLinks: boolOption{option: "keep-relative-links"},
379 | LoadErrorHandling: stringOption{option: "load-error-handling"},
380 | LoadMediaErrorHandling: stringOption{option: "load-media-error-handling"},
381 | MinimumFontSize: uintOption{option: "minimum-font-size"},
382 | NoBackground: boolOption{option: "no-background"},
383 | NoCustomHeaderPropagation: boolOption{option: "no-custom-header-propagation"},
384 | NoImages: boolOption{option: "no-images"},
385 | NoStopSlowScripts: boolOption{option: "no-stop-slow-scripts"},
386 | PageOffset: uintOption{option: "page-offset"},
387 | Password: stringOption{option: "password"},
388 | Post: mapOption{option: "post"},
389 | PostFile: mapOption{option: "post-file"},
390 | PrintMediaType: boolOption{option: "print-media-type"},
391 | Proxy: stringOption{option: "proxy"},
392 | ProxyHostnameLookup: boolOption{option: "proxy-hostname-lookup"},
393 | RadiobuttonCheckedSvg: stringOption{option: "radiobutton-checked-svg"},
394 | RadiobuttonSvg: stringOption{option: "radiobutton-svg"},
395 | RunScript: sliceOption{option: "run-script"},
396 | SslCrtPath: stringOption{option: "ssl-crt-path"},
397 | SslKeyPassword: stringOption{option: "ssl-key-password"},
398 | SslKeyPath: stringOption{option: "ssl-key-path"},
399 | Username: stringOption{option: "username"},
400 | UserStyleSheet: stringOption{option: "user-style-sheet"},
401 | ViewportSize: stringOption{option: "viewport-size"},
402 | WindowStatus: stringOption{option: "window-status"},
403 | Zoom: floatOption{option: "zoom"},
404 | }
405 | }
406 |
407 | func newHeaderAndFooterOptions() headerAndFooterOptions {
408 | return headerAndFooterOptions{
409 | FooterCenter: stringOption{option: "footer-center"},
410 | FooterFontName: stringOption{option: "footer-font-name"},
411 | FooterFontSize: uintOption{option: "footer-font-size"},
412 | FooterHTML: stringOption{option: "footer-html"},
413 | FooterLeft: stringOption{option: "footer-left"},
414 | FooterLine: boolOption{option: "footer-line"},
415 | FooterRight: stringOption{option: "footer-right"},
416 | FooterSpacing: floatOption{option: "footer-spacing"},
417 | HeaderCenter: stringOption{option: "header-center"},
418 | HeaderFontName: stringOption{option: "header-font-name"},
419 | HeaderFontSize: uintOption{option: "header-font-size"},
420 | HeaderHTML: stringOption{option: "header-html"},
421 | HeaderLeft: stringOption{option: "header-left"},
422 | HeaderLine: boolOption{option: "header-line"},
423 | HeaderRight: stringOption{option: "header-right"},
424 | HeaderSpacing: floatOption{option: "header-spacing"},
425 | Replace: mapOption{option: "replace"},
426 | }
427 | }
428 |
429 | func newTocOptions() tocOptions {
430 | return tocOptions{
431 | DisableDottedLines: boolOption{option: "disable-dotted-lines"},
432 | DisableTocLinks: boolOption{option: "disable-toc-links"},
433 | TocHeaderText: stringOption{option: "toc-header-text"},
434 | TocLevelIndentation: uintOption{option: "toc-level-indentation"},
435 | TocTextSizeShrink: floatOption{option: "toc-text-size-shrink"},
436 | XslStyleSheet: stringOption{option: "xsl-style-sheet"},
437 | }
438 | }
439 |
440 | func optsToArgs(opts interface{}) []string {
441 | args := make([]string, 0)
442 | rv := reflect.Indirect(reflect.ValueOf(opts))
443 | if rv.Kind() != reflect.Struct {
444 | return args
445 | }
446 | for i := 0; i < rv.NumField(); i++ {
447 | prsr, ok := rv.Field(i).Interface().(argParser)
448 | if ok {
449 | s := prsr.Parse()
450 | if len(s) > 0 {
451 | args = append(args, s...)
452 | }
453 | }
454 | }
455 | return args
456 | }
457 |
458 | // Constants for orientation modes
459 | const (
460 | OrientationLandscape = "Landscape" // Landscape mode
461 | OrientationPortrait = "Portrait" // Portrait mode
462 | )
463 |
464 | // Constants for page sizes
465 | const (
466 | PageSizeA0 = "A0" // 841 x 1189 mm
467 | PageSizeA1 = "A1" // 594 x 841 mm
468 | PageSizeA2 = "A2" // 420 x 594 mm
469 | PageSizeA3 = "A3" // 297 x 420 mm
470 | PageSizeA4 = "A4" // 210 x 297 mm, 8.26
471 | PageSizeA5 = "A5" // 148 x 210 mm
472 | PageSizeA6 = "A6" // 105 x 148 mm
473 | PageSizeA7 = "A7" // 74 x 105 mm
474 | PageSizeA8 = "A8" // 52 x 74 mm
475 | PageSizeA9 = "A9" // 37 x 52 mm
476 | PageSizeB0 = "B0" // 1000 x 1414 mm
477 | PageSizeB1 = "B1" // 707 x 1000 mm
478 | PageSizeB10 = "B10" // 31 x 44 mm
479 | PageSizeB2 = "B2" // 500 x 707 mm
480 | PageSizeB3 = "B3" // 353 x 500 mm
481 | PageSizeB4 = "B4" // 250 x 353 mm
482 | PageSizeB5 = "B5" // 176 x 250 mm, 6.93
483 | PageSizeB6 = "B6" // 125 x 176 mm
484 | PageSizeB7 = "B7" // 88 x 125 mm
485 | PageSizeB8 = "B8" // 62 x 88 mm
486 | PageSizeB9 = "B9" // 33 x 62 mm
487 | PageSizeC5E = "C5E" // 163 x 229 mm
488 | PageSizeComm10E = "Comm10E" // 105 x 241 mm, U.S. Common 10 Envelope
489 | PageSizeCustom = "Custom" // Unknown, or a user defined size.
490 | PageSizeDLE = "DLE" // 110 x 220 mm
491 | PageSizeExecutive = "Executive" // 7.5 x 10 inches, 190.5 x 254 mm
492 | PageSizeFolio = "Folio" // 210 x 330 mm
493 | PageSizeLedger = "Ledger" // 431.8 x 279.4 mm
494 | PageSizeLegal = "Legal" // 8.5 x 14 inches, 215.9 x 355.6 mm
495 | PageSizeLetter = "Letter" // 8.5 x 11 inches, 215.9 x 279.4 mm
496 | PageSizeTabloid = "Tabloid" // 279.4 x 431.8 mm
497 | )
498 |
--------------------------------------------------------------------------------
/testdata/html5.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | HTML5 Test Page
6 |
7 |
8 |
9 |
10 |
HTML5 Test Page
11 |
This is a test page filled with common HTML elements to be used to provide visual feedback whilst building CSS systems and frameworks.
12 |
13 |
14 |
56 |
57 |
58 |
59 |
Text
60 |
61 |
62 |
63 |
Headings
64 |
65 |
66 |
67 |
Heading 1
68 |
Heading 2
69 |
Heading 3
70 |
Heading 4
71 |
Heading 5
72 |
Heading 6
73 |
74 |
75 |
76 |
77 |
78 |
79 |
Paragraphs
80 |
81 |
82 |
A paragraph (from the Greek paragraphos, "to write beside" or "written beside") is a self-contained unit of a discourse in writing dealing with a particular point or idea. A paragraph consists of one or more sentences. Though not required by the syntax of any language, paragraphs are usually an expected part of formal writing, used to organize longer prose.
83 |
84 |
85 |
86 |
87 |
88 |
89 |
Blockquotes
90 |
91 |
92 |
93 |
A block quotation (also known as a long quotation or extract) is a quotation in a written document, that is set off from the main text as a paragraph, or block of text.
94 |
It is typically distinguished visually using indentation and a different typeface or smaller size quotation. It may or may not include a citation, usually placed at the bottom.
Sample output:This is sample output from a computer program.
207 |
208 |
Pre-formatted text
209 |
210 |
P R E F O R M A T T E D T E X T
211 | ! " # $ % & ' ( ) * + , - . /
212 | 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
213 | @ A B C D E F G H I J K L M N O
214 | P Q R S T U V W X Y Z [ \ ] ^ _
215 | ` a b c d e f g h i j k l m n o
216 | p q r s t u v w x y z { | } ~
