Merge pull request #6 from marcbachmann/windows-support

Windows support
fixes #5

Author: marcbachmann

Gruntfile.coffee

@@ -1,23 +1,23 @@
 module.exports = (grunt) ->
 
   grunt.initConfig
-    mochaTest:
+    mochacli:
       test:
         options:
           ui: 'bdd'
           reporter: 'spec'
-          require: ['coffee-script']
+          compilers: ['coffee:coffee-script/register']
           slow: '1ms'
-
-        src: ['test/**/*.coffee']
+          timeout: '10s'
+          files: 'test/**/*'
 
     watch:
       tests:
         files: ['test/**/*.coffee', 'lib/**/*.coffee']
-        tasks: ['mochaTest']
+        tasks: ['mochacli']
 
 
-  grunt.loadNpmTasks('grunt-mocha-test')
+  grunt.loadNpmTasks('grunt-mocha-cli')
   grunt.loadNpmTasks('grunt-contrib-watch')
 
-  grunt.registerTask('test', ['mochaTest', 'watch'])
+  grunt.registerTask('test', ['mochacli', 'watch'])

lib/index.coffee

@@ -3,35 +3,35 @@ spawn = require('child_process').spawn
 path = require('path')
 phantomjs = require('phantomjs')
 
-# 
+#
 # phantomjs version 1.8.1 and later should work. Ubuntu has some problems when trying to buffer to /dev/stdout
-# 
+#
 # Create a PDF file out of an html string.
-# 
+#
 # Regions for the PDF page are:
-# 
+#
 # - Page Header  -> document.getElementById('pageHeader')
 # - Page Content -> document.getElementById('pageContent')
 # - Page Footer  -> document.getElementById('pageFooter')
 #
 # When no #pageContent is available, phantomjs will use document.body as pdf content
-script = path.join(__dirname, 'scripts/pdf_a4_portrait.coffee')
+script = path.join(__dirname, 'scripts', 'pdf_a4_portrait.coffee')
 
 exports.create = (string, options, callback) ->
   if arguments.length == 2
     callback = options
     options = {}
 
-  return callback(new Error("Can't create pdf without content")) unless string?.length
-  child = spawn(phantomjs.path, [options.script || script, string.length, JSON.stringify(options)])
+  return callback(new Error("html-pdf: Can't create a pdf without content")) unless string?.length
+  child = spawn(phantomjs.path, [options.script || script])
   stdout = []
   stderr = []
 
   timeout = setTimeout ->
     child.stdin.end()
     child.kill()
-    stderr = [new Buffer('PDF creation timeout. PDF generation script did not end.')] unless stderr.length
-  , parseInt(options.timeout) || 10000
+    stderr = [new Buffer('html-pdf: PDF generation timeout. Phantom.js script did not exit.')] unless stderr.length
+  , parseInt(options.timeout) || 30000
 
   child.stdout.on 'data', (buffer) ->
     stdout.push(buffer)
@@ -45,23 +45,28 @@ exports.create = (string, options, callback) ->
     # Clean up the timeout cause the process ended anyways
     clearTimeout(timeout)
     if (stderr.length || code) > 0
-      error = new Error(Buffer.concat(stderr).toString())
+      error = new Error(Buffer.concat(stderr).toString() || 'html-pdf: Unknown Error')
       return callback(error)
 
     file = Buffer.concat(stdout)
-    if isFile = /^\%PDF/.test(file.slice(0, 4).toString())
-      callback(null, file)
+    isFileBuffer = /^\%PDF/.test(file.slice(0, 4).toString())
 
-    else
+    if options.filename
+      callback(null, file.toString())
+
+    else if !isFileBuffer
       filename = file.toString()
       fs.readFile filename, (err, buffer) ->
         return callback(err) if err
-
-        # Only delete file when options.filename is not defined
-        unless options.filename
-          fs.unlink filename, (err) ->
-            callback(err, buffer)
-        else
+        fs.unlink filename, (err) ->
           callback(err, buffer)
 
-  child.stdin.write(string, 'utf8')
+    else
+      callback(null, file)
+
+
+  content =
+    html: string
+    options: options
+
+  child.stdin.write(JSON.stringify(content)+'\n', 'utf8')

lib/index.js

@@ -8,27 +8,27 @@ path = require('path');
 
 phantomjs = require('phantomjs');
 
-script = path.join(__dirname, 'scripts/pdf_a4_portrait.coffee');
+script = path.join(__dirname, 'scripts', 'pdf_a4_portrait.coffee');
 
 exports.create = function(string, options, callback) {
-  var child, stderr, stdout, timeout;
+  var child, content, stderr, stdout, timeout;
   if (arguments.length === 2) {
     callback = options;
     options = {};
   }
   if (!(string != null ? string.length : void 0)) {
-    return callback(new Error("Can't create pdf without content"));
+    return callback(new Error("html-pdf: Can't create a pdf without content"));
   }
-  child = spawn(phantomjs.path, [options.script || script, string.length, JSON.stringify(options)]);
+  child = spawn(phantomjs.path, [options.script || script]);
   stdout = [];
   stderr = [];
   timeout = setTimeout(function() {
     child.stdin.end();
     child.kill();
     if (!stderr.length) {
-      return stderr = [new Buffer('PDF creation timeout. PDF generation script did not end.')];
+      return stderr = [new Buffer('html-pdf: PDF generation timeout. Phantom.js script did not exit.')];
     }
-  }, parseInt(options.timeout) || 10000);
+  }, parseInt(options.timeout) || 30000);
   child.stdout.on('data', function(buffer) {
     return stdout.push(buffer);
   });
@@ -38,30 +38,33 @@ exports.create = function(string, options, callback) {
     return child.kill();
   });
   child.on('exit', function(code) {
-    var error, file, filename, isFile;
+    var error, file, filename, isFileBuffer;
     clearTimeout(timeout);
     if ((stderr.length || code) > 0) {
-      error = new Error(Buffer.concat(stderr).toString());
+      error = new Error(Buffer.concat(stderr).toString() || 'html-pdf: Unknown Error');
       return callback(error);
     }
     file = Buffer.concat(stdout);
-    if (isFile = /^\%PDF/.test(file.slice(0, 4).toString())) {
-      return callback(null, file);
-    } else {
+    isFileBuffer = /^\%PDF/.test(file.slice(0, 4).toString());
+    if (options.filename) {
+      return callback(null, file.toString());
+    } else if (!isFileBuffer) {
       filename = file.toString();
       return fs.readFile(filename, function(err, buffer) {
         if (err) {
           return callback(err);
         }
-        if (!options.filename) {
-          return fs.unlink(filename, function(err) {
-            return callback(err, buffer);
-          });
-        } else {
+        return fs.unlink(filename, function(err) {
           return callback(err, buffer);
-        }
+        });
       });
+    } else {
+      return callback(null, file);
     }
   });
-  return child.stdin.write(string, 'utf8');
+  content = {
+    html: string,
+    options: options
+  };
+  return child.stdin.write(JSON.stringify(content) + '\n', 'utf8');
 };

lib/scripts/pdf_a4_portrait.coffee

@@ -1,11 +1,26 @@
-sys = require('system')
+system = require('system')
 webpage = require('webpage')
 
+# Error handler
+exit = (error) ->
+  message = error if typeof error is 'string'
+  system.stderr.write("html-pdf: #{message || "Unknown Error #{error}"}\n") if error
+  phantom.exit(if error then 1 else 0)
+
+
+# Force cleanup after 2 minutes
+setTimeout ->
+  exit('Force timeout')
+, 120000
+
+
+# Load configurations from stdin
+json = JSON.parse(system.stdin.readLine())
+exit('Did not receive any html') if !json.html?.trim()
+
+options = json.options
 page = webpage.create()
-bufferSize = sys.args[1]
-options = {}
-options = JSON.parse(sys.args[2]) if typeof sys.args[2] is 'string'
-page.content = sys.stdin.read(bufferSize)
+page.content = json.html
 
 
 # Set up content
@@ -71,17 +86,15 @@ page.onLoadFinished = (status) ->
     type: options.type || 'pdf'
     quality: options.quality || 75
 
-  # Option 1: Output file to stdout
-  # Not working in Ubuntu 12.04 (at least not in my environment)
-  if options.buffer
-    page.render('/dev/stdout', fileOptions)
-
+  if !options.buffer
+    filename = options.filename || ("#{options.directory || '/tmp'}/html-pdf-#{system.pid}.#{fileOptions.type}")
+    page.render(filename, fileOptions)
+    system.stdout.write(filename)
 
-  # Option 2: Output filename to stdout
+  # Deprecated options.buffer method
   else
-    filename = options.filename || ("#{options.directory || '/tmp'}/html-pdf-#{sys.pid}-#{bufferSize}.#{fileOptions.type}")
-    page.render(filename, fileOptions)
-    sys.stdout.write(filename)
+    system.stderr.write('html-pdf: options.buffer is deprecated. Because of compatibility issues this method is longer supported.\n')
+    page.render('/dev/stdout', fileOptions)
 
 
-  phantom.exit(0)
+  exit(null)

package.json

@@ -12,15 +12,16 @@
   "author": "Marc Bachmann",
   "license": "MIT",
   "devDependencies": {
-    "coffee-script": "^1.7.1",
     "chai": "^1.9.1",
-    "grunt-mocha-test": "^0.10.2",
-    "grunt": "^0.4.4",
-    "mocha": "^1.18.2",
-    "grunt-contrib-watch": "^0.6.1"
+    "coffee-script": "^1.7.1",
+    "grunt": "^0.4.5",
+    "grunt-cli": "^0.1.13",
+    "grunt-contrib-watch": "^0.6.1",
+    "grunt-mocha-cli": "^1.11.0",
+    "mocha": "^1.18.2"
   },
   "dependencies": {
-    "phantomjs": "^1.9.7-8"
+    "phantomjs": "^1.9.8"
   },
   "repository": {
     "type": "git",

test/create.coffee

@@ -17,7 +17,7 @@ describe 'html-pdf', ->
             <div id="pageContent">Content</div>
             <div id="pageFooter">Footer</div>
           </body>
-        </html> 
+        </html>
       """
 
     it 'throws error when passing null', (done) ->
@@ -40,17 +40,29 @@ describe 'html-pdf', ->
 
     it 'does not throw an error when succeeding', (done) ->
       pdf.create @html, (error, pdf) =>
-        @pdf = pdf
         expect(error).to.be.null
-        fs.writeFile(path.join(__dirname,'simple.pdf'), pdf)
         done()
 
-    it 'returns a buffer', ->
-      expect(Buffer.isBuffer(@pdf), 'Should be a buffer').to.be.equal(true)
 
+    it 'buffer must be returned when no filename specified', (done) ->
+      pdf.create @html, (error, pdf) =>
+        expect(pdf).to.be.defined
+        done()
+
+
+    it 'returns a pdf buffer', (done) ->
+      pdf.create @html, (error, pdf) =>
+        expect(Buffer.isBuffer(pdf), 'Expect to be a pdf Buffer').to.be.equal(true)
+        expect(/^\%PDF-1.4/.test(pdf.toString()), 'Has a PDF header').to.be.equal(true)
+        done()
+
+
+    it 'saves the pdf to a destination', (done) ->
+      file = path.join(__dirname,'simple.pdf')
+      pdf.create @html, filename: file, (error, pdf) =>
+        expect(fs.existsSync(path.join(__dirname,'simple.pdf'))).to.equal(true)
+        done()
 
-    it 'returns a pdf buffer', ->
-      expect(/^\%PDF-1.4/.test(@pdf.toString()), 'Has a PDF header').to.be.equal(true)
 
     it 'works with a custom page size and footer', (done) ->
       options =
@@ -71,8 +83,9 @@ describe 'html-pdf', ->
       options =
         width: '50mm'
         height: '90mm'
+        filename: path.join(__dirname,'businesscard.pdf')
 
       pdf.create html, options,(error, pdf) =>
-        fs.writeFile(path.join(__dirname,'businesscard.pdf'), pdf)
         expect(error).to.be.null
+        expect(fs.existsSync(options.filename)).to.equal(true)
         done()