API reference

node = gobble( 'foo' )

Returns a node object representing the contents of the 'foo' directory.

node = gobble([ node1, node2[, ...nodeN] ])

Returns the result of merging the input nodes. Later files overwrite earlier ones.

node2 = node1.transform( transformer, options )

Returns a tree that is the result of applying transformer to node1. The transformer function takes five arguments - inputDir, outputDir, options, callback and errback:

• inputDir - the folder to read files from
• outputDir - the folder to write files to
• options - the options passed into the transform method (or {}, if none)
• callback - a function that you must call once you've finished writing files
• errback - if an error occurs, call errback(error)

Asynchronous operations are preferred. gobble.file contains a bunch of useful filesystem helpers that return promises, which help deal with node callback hell. (Docs coming soon!)

node.inspect( 'tmp/some-dir'[, options] )

Sometimes it's useful, for debugging purposes, to dump part of your build to disk in order to inspect it. This method will continuously write the contents of node to 'tmp-some-dir' whenever they change, as long as Gobble is running. It returns this, so it doesn't affect the build in any way - it's just a convenient way to see what's going on.

Built-in transforms

There are a handful of built-in transforms:

node.include( patterns )

Filters out any files that don't match patterns. patterns can be a minimatch string, or an array of them.

node.exclude( patterns )

Opposite of node.include(patterns).

node.map( fn[, options] )

For one-to-one replacements (e.g. transpiling coffeescript). fn is a function that takes two arguments - content and options, where content is the contents of the file to process, and options is the options argument passed into map. The function must return the replacement content.