Issue 143 in memory output, ava and electron version bumps (#146)

* Added a job option to only hold the PDF in memory and not persist to disk, fixes #143
* got rid of bluebird and bumped electron version #143
* factored out common events #143
* added a destroy method to cleanup windows left open to address seg fault when streaming buffer objects from the client #143

Author: codecounselor

README.md

@@ -68,7 +68,18 @@ exporter.start()
 ```javascript
 app.post('/pdfexport', function(req,res){
 	// derive job arguments from request here
-	exporter.createJob(source, target, options).then( job => {
+	// 
+	const jobOptions = {
+	  /**
+	    r.results[] will contain the following based on inMemory
+          false: the fully qualified path to a PDF file on disk
+          true: The Buffer Object as returned by Electron
+	    
+	    Note: the default is false, this can not be set using the CLI
+	   */
+	  inMemory: false 
+	}
+	exporter.createJob(source, target, options, jobOptions).then( job => {
 	job.on('job-complete', (r) => {
     		console.log('pdf files:', r.results)
     		// Process the PDF file(s) here
@@ -78,6 +89,25 @@ app.post('/pdfexport', function(req,res){
 })
 ```
 
+#### Using an in memory Buffer
+
+If you set the `inMemory` setting to true, you must also set `closeWindow=true`
+or you will get a segmentation fault anytime the window is closed before the buffer 
+is sent on the response.  You then need to invoke `job.destroy` to close the window.
+
+Sample Code:
+```javascript
+const jobOptions = { inMemory: true, closeWindow: false }
+exporter.createJob(source, target, options, jobOptions).then( job => {
+	job.on('job-complete', (r) => {
+	  //Send the Buffer here
+	  process.nextTick(() => {job.destroy()})
+	})
+})
+```
+
+## Events
+
 The API is designed to emit noteworthy events rather than use callbacks.
 Full documentation of all events is a work in progress.
 

lib/exportJob.js

@@ -10,7 +10,7 @@ const url = require('url')
 const _ = require('lodash')
 const EventEmitter = require('eventemitter2').EventEmitter2
 const electron = require('electron')
-var uuid = require('uuid')
+const uuid = require('uuid')
 
 // Logging
 const debug = require('debug')
@@ -24,7 +24,8 @@ const MICRONS_INCH_RATIO = 25400
 const MAX_EVENT_WAIT = 10000
 
 const DEFAULT_OPTIONS = {
-  closeWindow: true
+  closeWindow: true,
+  inMemory: false
 }
 
 class ExportJob extends EventEmitter {
@@ -33,18 +34,22 @@ class ExportJob extends EventEmitter {
    *
    * @param {Array} input The path to the HTML or url, or a markdown file
    *   with 'md' or 'markdown' extension.
+   *
    * @param output The name of the file to export to.  If the extension is
    *   '.png' then a PNG image will be generated instead of a PDF.
+   *
    * @param args {Object} the minimist arg object
+   *
    * @param options {Object} electron-pdf options
    * @param options.closeWindow default:true - If set to false, the window will
    *   not be closed when the job is complete.  This can be useful if you wish
    *   to reuse a window by passing it to the render function.
+   * @param options.inMemory default:false - If set to true then `output` will be
+   * ignored and the results array will contain the Buffer object of the PDF
    *
-   * @fires ExportJob#export-complete after each export is available on the
-   *   filesystem
-   * @fires ExportJob#job-complete after all export resources are available on
-   *   the filesystem
+   * @fires ExportJob#window.capture.end after each resource is captured (use this with inMemory)
+   * @fires ExportJob#export-complete after each resource is available in memory or on the filesystem
+   * @fires ExportJob#job-complete after all export resources are available on the filesystem
    */
   constructor (input, output, args, options) {
     super()
@@ -139,10 +144,12 @@ class ExportJob extends EventEmitter {
    *  args[0]: the details object from CustomEvent
    *
    * @fires PDFExporter#window.observer.start when the observer is invoked
-   * @fires PDFExporter#window.observer.timeout when the promise is not observed by
-   * the maximum wait time (default: 10 seconds).  The process will continue on and
-   * capture the page, it is up to the caller to handle this event accordingly.
-   * @fires PDFExporter#window.observer.end when the observer fulfills the promise
+   * @fires PDFExporter#window.observer.timeout when the promise is not
+   *   observed by the maximum wait time (default: 10 seconds).  The process
+   *   will continue on and capture the page, it is up to the caller to handle
+   *   this event accordingly.
+   * @fires PDFExporter#window.observer.end when the observer fulfills the
+   *   promise
    */
   observeReadyEvent (handler) {
     this.readyEventObserver = handler
@@ -163,6 +170,18 @@ class ExportJob extends EventEmitter {
     this.args[arg] = value
   }
 
+  /**
+   * Invoke this method to ensure that any allocated resources are destroyed
+   * Resources managed:
+   * - this.window
+   */
+  destroy () {
+    logger('job is tearing down')
+    if (this.window) {
+      this.window.close()
+    }
+  }
+
   // ***************************************************************************
   // ************************* Private Functions *******************************
   // ***************************************************************************
@@ -464,23 +483,23 @@ class ExportJob extends EventEmitter {
     window.webContents.executeJavaScript('document.documentElement.outerHTML', result => {
       const target = path.resolve(outputFile)
       fs.writeFile(target, result, function (err) {
-        this.emit('window.capture.end', {file: target, error: err})
-        this.emit('export-complete', {file: target})
-        done(err, target)
+        this._emitResourceEvents(err, target, done)
       }.bind(this))
     })
   }
 
   _captureImage (window, outputFile, done) {
     window.webContents.capturePage(image => {
-      const target = path.resolve(outputFile)
-      fs.writeFile(target, image.toPNG(), function (err) {
-        this.emit('window.capture.end', {file: target, error: err})
-        this.emit('export-complete', {file: target})
-        // REMOVE pdf-complete in 2.0 - keeping for backwards compatibility
-        this.emit('pdf-complete', {file: target})
-        done(err, target)
-      }.bind(this))
+      // http://electron.atom.io/docs/api/native-image/#imagetopng
+      const pngBuffer = image.toPNG()
+      if (this.options.inMemory) {
+        this._emitResourceEvents(undefined, pngBuffer, done)
+      } else {
+        const target = path.resolve(outputFile)
+        fs.writeFile(target, pngBuffer, function (err) {
+          this._emitResourceEvents(err, target, done)
+        }.bind(this))
+      }
     })
   }
 
@@ -493,31 +512,55 @@ class ExportJob extends EventEmitter {
       pageSize: args.pageSize,
       landscape: args.landscape
     }
+    window.webContents.printToPDF(pdfOptions, this._handlePDF.bind(this, outputFile, done))
+  }
 
-    window.webContents.printToPDF(pdfOptions, (err, data) => {
-      if (err) {
-        this.emit('window.capture.end', {error: err})
-        done(err)
-      } else {
-        const target = path.resolve(outputFile)
-        fs.writeFile(target, data, (err) => {
-          if (!err) {
-            // REMOVE in 2.0 - keeping for backwards compatibility
-            this.emit('pdf-complete', {file: target})
-            /**
-             * Generation Event - fires when an export has be persisted to
-             * disk
-             * @event PDFExporter#export-complete
-             * @type {object}
-             * @property {String} file - Path to the File
-             */
-            this.emit('export-complete', {file: target})
-          }
-          this.emit('window.capture.end', {file: target, error: err})
-          done(err, target)
-        })
-      }
-    })
+  /**
+   * The callback function for when printToPDF is complete
+   * @param err
+   * @param data
+   * @private
+   */
+  _handlePDF (outputFile, done, err, data) {
+    if (this.options.inMemory || err) {
+      this._emitResourceEvents(err, data, done)
+    } else {
+      const target = path.resolve(outputFile)
+      fs.writeFile(target, data, (fileWriteErr) => {
+        // REMOVE in 2.0 - keeping for backwards compatibility
+        this.emit('pdf-complete', {file: target, error: fileWriteErr})
+        this._emitResourceEvents(fileWriteErr, target, done)
+      })
+    }
+  }
+
+  /**
+   * Emits events when a resource has been captured or an error has occurred
+   * while attempting the capture.
+   *
+   * @param err
+   * @param data
+   * @param done
+   * @private
+   */
+  _emitResourceEvents (err, data, done) {
+    /**
+     * Window Event - fires when an export has captured the window (succesfully
+     * or not)
+     * @event PDFExporter#export-complete
+     * @type {object}
+     * @property {Buffer} data - The Buffer holding the PDF file
+     * @property {Object} error - If an error occurred, undefined otherwise
+     */
+    this.emit('window.capture.end', {data: data, error: err})
+    /**
+     * Generation Event - fires when an export has be persisted to disk
+     * @event PDFExporter#export-complete
+     * @type {object}
+     * @property {String} file - Path to the File
+     */
+    this.emit('export-complete', {data: data})
+    done(err, data)
   }
 
   /**

lib/index.js

@@ -1,7 +1,6 @@
 'use strict'
 
 var EventEmitter = require('events').EventEmitter
-var Promise = require('bluebird')
 
 var electron = require('electron')
 var minimist = require('minimist')
@@ -65,7 +64,8 @@ class PDFExporter extends EventEmitter {
    * @param output {String} Filename
    * @param args {array|Object} command line args - Can be an array of any
    *   supported args, or an object that is the result of running minimist.
-   *
+   * @param options {Object} export args - see ExportJob for list of options.
+   * These are options only supported by the API and not by the CLI
    */
   createJob (input, output, args, options) {
     if (!this.isReady) {

lib/source.js

@@ -4,7 +4,6 @@ var _ = require('lodash')
 var path = require('path')
 // var wargs = require('./args')
 var markdownToHTMLPath = require('./markdown')
-var Promise = require('bluebird')
 
 // Logging
 const debug = require('debug')

package.json

@@ -35,7 +35,7 @@
   },
   "homepage": "https://github.com/fraserxu/electron-pdf",
   "devDependencies": {
-    "ava": "^0.16.0",
+    "ava": "^0.17.0",
     "jasmine": "^2.5.2",
     "standard": "^8.4.0",
     "tap-diff": "^0.1.1",
@@ -44,9 +44,8 @@
   },
   "dependencies": {
     "async": "^2.0.1",
-    "bluebird": "^3.4.6",
     "debug": "^2.3.2",
-    "electron": "^1.4.6",
+    "electron": "^1.4.12",
     "eventemitter2": "^2.1.3",
     "github-markdown-css": "^2.0.9",
     "highlight.js": "^9.0.0",

test/exportJob-test.js

@@ -9,11 +9,12 @@ const micronDims = {
   height: 228600
 }
 
+const args = {}
 const options = {
   pageSize: JSON.stringify(micronDims)
 }
 
-let job = new ExportJob(['input'], 'output.pdf', options)
+let job = new ExportJob(['input'], 'output.pdf', args, options)
 
 // Construction
 /**
@@ -94,6 +95,38 @@ test('setSessionCookie_multiple', t => {
   })
 })
 
+// PDF Completion Tests
+
+test.cb('handlePDF_electronError', t => {
+  const cb = (e, d) => {
+    t.is(e, 'error occurred')
+    t.end()
+  }
+  job._handlePDF('output.pdf', cb, 'error occurred', undefined)
+})
+
+test.cb('handlePDF_inMemory', t => {
+  // Arrange
+  const opts = _.extend({}, options, {inMemory: true})
+  const inMemJob = new ExportJob(['input'], 'output.pdf', {}, opts)
+  let windowEventData
+  inMemJob.on('window.capture.end', (event) => {
+    windowEventData = event.data
+  })
+  const err = undefined
+  const data = 'binaryPDFDataWouldGoHere'
+
+  // Assert
+  const cb = (e, d) => {
+    t.is(d, windowEventData) // the window.capture.end event was emitted with data
+    t.is(d, data) // The raw data was returned and not a filepath
+    t.end()
+  }
+
+  // Act
+  inMemJob._handlePDF('output.pdf', cb, err, data)
+})
+
 // Support Functions
 /**
  * Stubs the windows.sessionn.cookies object and provides access

test/source-test.js

@@ -16,7 +16,7 @@ test('resolve() handles arrays of strings', t => {
 })
 
 test('resolve() converts markdown to html', t => {
-  source.resolve(['../README.md'], {}).then(result => {
+  source.resolve(['./README.md'], {}).then(result => {
     t.is(result.length, 1)
     t.truthy(result[0].endsWith('.html'))
   })