The coffee utility. Handles command-line compilation of CoffeeScript
into various forms: saved into .js files or printed to stdout
or recompiled every time the source is saved,
printed as a token stream or as the syntax tree, or launch an
interactive REPL.
External dependencies.
fs = require 'fs'
path = require 'path'
helpers = require './helpers'
optparse = require './optparse'
CoffeeScript = require './'
{spawn, exec} = require 'child_process'
{EventEmitter} = require 'events'
useWinPathSep = path.sep is '\\'Allow CoffeeScript to emit Node.js events.
helpers.extend CoffeeScript, new EventEmitter
printLine = (line) -> process.stdout.write line + '\n'
printWarn = (line) -> process.stderr.write line + '\n'
hidden = (file) -> /^\.|~$/.test fileThe help banner that is printed in conjunction with -h/--help.
BANNER = '''
Usage: coffee [options] path/to/script.coffee [args]
If called without options, `coffee` will run your script.
'''The list of all the valid option flags that coffee knows how to handle.
SWITCHES = [
[ '--ast', 'generate an abstract syntax tree of nodes']
['-b', '--bare', 'compile without a top-level function wrapper']
['-c', '--compile', 'compile to JavaScript and save as .js files']
['-e', '--eval', 'pass a string from the command line as input']
['-h', '--help', 'display this help message']
['-i', '--interactive', 'run an interactive CoffeeScript REPL']
['-j', '--join [FILE]', 'concatenate the source CoffeeScript before compiling']
['-l', '--literate', 'treat stdio as literate style coffeescript']
['-m', '--map', 'generate source map and save as .js.map files']
['-M', '--inline-map', 'generate source map and include it directly in output']
['-n', '--nodes', 'print out the parse tree that the parser produces']
[ '--nodejs [ARGS]', 'pass options directly to the "node" binary']
[ '--no-header', 'suppress the "Generated by" header']
['-o', '--output [PATH]', 'set the output path or path/filename for compiled JavaScript']
['-p', '--print', 'print out the compiled JavaScript']
['-r', '--require [MODULE*]', 'require the given module before eval or REPL']
['-s', '--stdio', 'listen for and compile scripts over stdio']
['-t', '--transpile', 'pipe generated JavaScript through Babel']
[ '--tokens', 'print out the tokens that the lexer/rewriter produce']
['-v', '--version', 'display the version number']
['-w', '--watch', 'watch scripts for changes and rerun commands']
]Top-level objects shared by all the functions.
opts = {}
sources = []
sourceCode = []
notSources = {}
watchedDirs = {}
optionParser = null
exports.buildCSOptionParser = buildCSOptionParser = ->
new optparse.OptionParser SWITCHES, BANNERRun coffee by parsing passed options and determining what action to take.
Many flags cause us to divert before compiling anything. Flags passed after
-- will be passed verbatim to your script as arguments in process.argv
exports.run = ->
optionParser = buildCSOptionParser()
try parseOptions()
catch err
console.error "option parsing error: #{err.message}"
process.exit 1
if (not opts.doubleDashed) and (opts.arguments[1] is '--')
printWarn '''
coffee was invoked with '--' as the second positional argument, which is
now deprecated. To pass '--' as an argument to a script to run, put an
additional '--' before the path to your script.
'--' will be removed from the argument list.
'''
printWarn "The positional arguments were: #{JSON.stringify opts.arguments}"
opts.arguments = [opts.arguments[0]].concat opts.arguments[2..]Make the REPL CLI use the global context so as to (a) be consistent with the
node REPL CLI and, therefore, (b) make packages that modify native prototypes
(such as ‘colors’ and ‘sugar’) work as expected.
replCliOpts = useGlobal: yes
opts.prelude = makePrelude opts.require if opts.require
replCliOpts.prelude = opts.prelude
replCliOpts.transpile = opts.transpile
return forkNode() if opts.nodejs
return usage() if opts.help
return version() if opts.version
return require('./repl').start(replCliOpts) if opts.interactive
return compileStdio() if opts.stdio
return compileScript null, opts.arguments[0] if opts.eval
return require('./repl').start(replCliOpts) unless opts.arguments.length
literals = if opts.run then opts.arguments.splice 1 else []
process.argv = process.argv[0..1].concat literals
process.argv[0] = 'coffee'
if opts.output
outputBasename = path.basename opts.output
if '.' in outputBasename and
outputBasename not in ['.', '..'] and
not helpers.ends(opts.output, path.sep)An output filename was specified, e.g. /dist/scripts.js.
opts.outputFilename = outputBasename
opts.outputPath = path.resolve path.dirname opts.output
elseAn output path was specified, e.g. /dist.
opts.outputFilename = null
opts.outputPath = path.resolve opts.output
if opts.join
opts.join = path.resolve opts.join
console.error '''
The --join option is deprecated and will be removed in a future version.
If for some reason it's necessary to share local variables between files,
replace...
$ coffee --compile --join bundle.js -- a.coffee b.coffee c.coffee
with...
$ cat a.coffee b.coffee c.coffee | coffee --compile --stdio > bundle.js
'''
for source in opts.arguments
source = path.resolve source
compilePath source, yes, source
makePrelude = (requires) ->
requires.map (module) ->
[full, name, module] = match if match = module.match(/^(.*)=(.*)$/)
name or= helpers.baseFileName module, yes, useWinPathSep
"global['#{name}'] = require('#{module}')"
.join ';'Compile a path, which could be a script or a directory. If a directory is passed, recursively compile all ‘.coffee’, ‘.litcoffee’, and ‘.coffee.md’ extension source files in it and all subdirectories.
compilePath = (source, topLevel, base) ->
return if source in sources or
watchedDirs[source] or
not topLevel and (notSources[source] or hidden source)
try
stats = fs.statSync source
catch err
if err.code is 'ENOENT'
console.error "File not found: #{source}"
process.exit 1
throw err
if stats.isDirectory()
if path.basename(source) is 'node_modules'
notSources[source] = yes
return
if opts.run
compilePath findDirectoryIndex(source), topLevel, base
return
watchDir source, base if opts.watch
try
files = fs.readdirSync source
catch err
if err.code is 'ENOENT' then return else throw err
for file in files
compilePath (path.join source, file), no, base
else if topLevel or helpers.isCoffee source
sources.push source
sourceCode.push null
delete notSources[source]
watch source, base if opts.watch
try
code = fs.readFileSync source
catch err
if err.code is 'ENOENT' then return else throw err
compileScript source, code.toString(), base
else
notSources[source] = yes
findDirectoryIndex = (source) ->
for ext in CoffeeScript.FILE_EXTENSIONS
index = path.join source, "index#{ext}"
try
return index if (fs.statSync index).isFile()
catch err
throw err unless err.code is 'ENOENT'
console.error "Missing index.coffee or index.litcoffee in #{source}"
process.exit 1Compile a single source script, containing the given code, according to the
requested options. If evaluating the script directly, set __filename,
__dirname and module.filename to be correct relative to the script’s path.
compileScript = (file, input, base = null) ->
options = compileOptions file, base
try
task = {file, input, options}
CoffeeScript.emit 'compile', task
if opts.tokens
printTokens CoffeeScript.tokens task.input, task.options
else if opts.nodes
printLine CoffeeScript.nodes(task.input, task.options).toString().trim()
else if opts.ast
compiled = CoffeeScript.compile task.input, task.options
printLine JSON.stringify(compiled, null, 2)
else if opts.run
CoffeeScript.register()
CoffeeScript.eval opts.prelude, task.options if opts.prelude
CoffeeScript.run task.input, task.options
else if opts.join and task.file isnt opts.join
task.input = helpers.invertLiterate task.input if helpers.isLiterate file
sourceCode[sources.indexOf(task.file)] = task.input
compileJoin()
else
compiled = CoffeeScript.compile task.input, task.options
task.output = compiled
if opts.map
task.output = compiled.js
task.sourceMap = compiled.v3SourceMap
CoffeeScript.emit 'success', task
if opts.print
printLine task.output.trim()
else if opts.compile or opts.map
saveTo = if opts.outputFilename and sources.length is 1
path.join opts.outputPath, opts.outputFilename
else
options.jsPath
writeJs base, task.file, task.output, saveTo, task.sourceMap
catch err
CoffeeScript.emit 'failure', err, task
return if CoffeeScript.listeners('failure').length
message = err?.stack or "#{err}"
if opts.watch
printLine message + '\x07'
else
printWarn message
process.exit 1Attach the appropriate listeners to compile scripts incoming over stdin, and write them back to stdout.
compileStdio = ->
if opts.map
console.error '--stdio and --map cannot be used together'
process.exit 1
buffers = []
stdin = process.openStdin()
stdin.on 'data', (buffer) ->
buffers.push buffer if buffer
stdin.on 'end', ->
compileScript null, Buffer.concat(buffers).toString()If all of the source files are done being read, concatenate and compile them together.
joinTimeout = null
compileJoin = ->
return unless opts.join
unless sourceCode.some((code) -> code is null)
clearTimeout joinTimeout
joinTimeout = wait 100, ->
compileScript opts.join, sourceCode.join('\n'), opts.joinWatch a source CoffeeScript file using fs.watch, recompiling it every
time the file is updated. May be used in combination with other options,
such as --print.
watch = (source, base) ->
watcher = null
prevStats = null
compileTimeout = null
watchErr = (err) ->
throw err unless err.code is 'ENOENT'
return unless source in sources
try
rewatch()
compile()
catch
removeSource source, base
compileJoin()
compile = ->
clearTimeout compileTimeout
compileTimeout = wait 25, ->
fs.stat source, (err, stats) ->
return watchErr err if err
return rewatch() if prevStats and
stats.size is prevStats.size and
stats.mtime.getTime() is prevStats.mtime.getTime()
prevStats = stats
fs.readFile source, (err, code) ->
return watchErr err if err
compileScript(source, code.toString(), base)
rewatch()
startWatcher = ->
watcher = fs.watch source
.on 'change', compile
.on 'error', (err) ->
throw err unless err.code is 'EPERM'
removeSource source, base
rewatch = ->
watcher?.close()
startWatcher()
try
startWatcher()
catch err
watchErr errWatch a directory of files for new additions.
watchDir = (source, base) ->
watcher = null
readdirTimeout = null
startWatcher = ->
watcher = fs.watch source
.on 'error', (err) ->
throw err unless err.code is 'EPERM'
stopWatcher()
.on 'change', ->
clearTimeout readdirTimeout
readdirTimeout = wait 25, ->
try
files = fs.readdirSync source
catch err
throw err unless err.code is 'ENOENT'
return stopWatcher()
for file in files
compilePath (path.join source, file), no, base
stopWatcher = ->
watcher.close()
removeSourceDir source, base
watchedDirs[source] = yes
try
startWatcher()
catch err
throw err unless err.code is 'ENOENT'
removeSourceDir = (source, base) ->
delete watchedDirs[source]
sourcesChanged = no
for file in sources when source is path.dirname file
removeSource file, base
sourcesChanged = yes
compileJoin() if sourcesChangedRemove a file from our source list, and source code cache. Optionally remove the compiled JS version as well.
removeSource = (source, base) ->
index = sources.indexOf source
sources.splice index, 1
sourceCode.splice index, 1
unless opts.join
silentUnlink outputPath source, base
silentUnlink outputPath source, base, '.js.map'
timeLog "removed #{source}"
silentUnlink = (path) ->
try
fs.unlinkSync path
catch err
throw err unless err.code in ['ENOENT', 'EPERM']Get the corresponding output JavaScript path for a source file.
outputPath = (source, base, extension=".js") ->
basename = helpers.baseFileName source, yes, useWinPathSep
srcDir = path.dirname source
dir = unless opts.outputPath
srcDir
else if source is base
opts.outputPath
else
path.join opts.outputPath, path.relative base, srcDir
path.join dir, basename + extensionRecursively mkdir, like mkdir -p.
mkdirp = (dir, fn) ->
mode = 0o777 & ~process.umask()
do mkdirs = (p = dir, fn) ->
fs.exists p, (exists) ->
if exists
fn()
else
mkdirs path.dirname(p), ->
fs.mkdir p, mode, (err) ->
return fn err if err
fn()Write out a JavaScript source file with the compiled code. By default, files
are written out in cwd as .js files with the same name, but the output
directory can be customized with --output.
If generatedSourceMap is provided, this will write a .js.map file into the
same directory as the .js file.
writeJs = (base, sourcePath, js, jsPath, generatedSourceMap = null) ->
sourceMapPath = "#{jsPath}.map"
jsDir = path.dirname jsPath
compile = ->
if opts.compile
js = ' ' if js.length <= 0
if generatedSourceMap then js = "#{js}\n//# sourceMappingURL=#{helpers.baseFileName sourceMapPath, no, useWinPathSep}\n"
fs.writeFile jsPath, js, (err) ->
if err
printLine err.message
process.exit 1
else if opts.compile and opts.watch
timeLog "compiled #{sourcePath}"
if generatedSourceMap
fs.writeFile sourceMapPath, generatedSourceMap, (err) ->
if err
printLine "Could not write source map: #{err.message}"
process.exit 1
fs.exists jsDir, (itExists) ->
if itExists then compile() else mkdirp jsDir, compileConvenience for cleaner setTimeouts.
wait = (milliseconds, func) -> setTimeout func, millisecondsWhen watching scripts, it’s useful to log changes with the timestamp.
timeLog = (message) ->
console.log "#{(new Date).toLocaleTimeString()} - #{message}"Pretty-print a stream of tokens, sans location data.
printTokens = (tokens) ->
strings = for token in tokens
tag = token[0]
value = token[1].toString().replace(/\n/, '\\n')
"[#{tag} #{value}]"
printLine strings.join(' ')Use the OptionParser module to extract all options from
process.argv that are specified in SWITCHES.
parseOptions = ->
o = opts = optionParser.parse process.argv[2..]
o.compile or= !!o.output
o.run = not (o.compile or o.print or o.map)
o.print = !! (o.print or (o.eval or o.stdio and o.compile))The compile-time options to pass to the CoffeeScript compiler.
compileOptions = (filename, base) ->
if opts.transpileThe user has requested that the CoffeeScript compiler also transpile via Babel. We don’t include Babel as a dependency because we want to avoid dependencies in general, and most users probably won’t be relying on us to transpile for them; we assume most users will probably either run CoffeeScript’s output without transpilation (modern Node or evergreen browsers) or use a proper build chain like Gulp or Webpack.
try
require '@babel/core'
catch
try
require 'babel-core'
catchGive appropriate instructions depending on whether coffee was run
locally or globally.
if require.resolve('.').indexOf(process.cwd()) is 0
console.error '''
To use --transpile, you must have @babel/core installed:
npm install --save-dev @babel/core
And you must save options to configure Babel in one of the places it looks to find its options.
See https://coffeescript.org/#transpilation
'''
else
console.error '''
To use --transpile with globally-installed CoffeeScript, you must have @babel/core installed globally:
npm install --global @babel/core
And you must save options to configure Babel in one of the places it looks to find its options, relative to the file being compiled or to the current folder.
See https://coffeescript.org/#transpilation
'''
process.exit 1
opts.transpile = {} unless typeof opts.transpile is 'object'Pass a reference to Babel into the compiler, so that the transpile option
is available for the CLI. We need to do this so that tools like Webpack
can require('coffeescript') and build correctly, without trying to
require Babel.
opts.transpile.transpile = CoffeeScript.transpileBabel searches for its options (a .babelrc file, a .babelrc.js file,
a package.json file with a babel key, etc.) relative to the path
given to it in its filename option. Make sure we have a path to pass
along.
unless opts.transpile.filename
opts.transpile.filename = filename or path.resolve(base or process.cwd(), '<anonymous>')
else
opts.transpile = no
answer =
filename: filename
literate: opts.literate or helpers.isLiterate(filename)
bare: opts.bare
header: opts.compile and not opts['no-header']
transpile: opts.transpile
sourceMap: opts.map
inlineMap: opts['inline-map']
ast: opts.ast
if filename
if base
cwd = process.cwd()
jsPath = outputPath filename, base
jsDir = path.dirname jsPath
answer = helpers.merge answer, {
jsPath
sourceRoot: path.relative(jsDir, cwd) + path.sep
sourceFiles: [path.relative cwd, filename]
generatedFile: helpers.baseFileName(jsPath, no, useWinPathSep)
}
else
answer = helpers.merge answer,
sourceRoot: ""
sourceFiles: [helpers.baseFileName filename, no, useWinPathSep]
generatedFile: helpers.baseFileName(filename, yes, useWinPathSep) + ".js"
answerStart up a new Node.js instance with the arguments in --nodejs passed to
the node binary, preserving the other options.
forkNode = ->
nodeArgs = opts.nodejs.split /\s+/
args = process.argv[1..]
args.splice args.indexOf('--nodejs'), 2
p = spawn process.execPath, nodeArgs.concat(args),
cwd: process.cwd()
env: process.env
stdio: [0, 1, 2]
for signal in ['SIGINT', 'SIGTERM']
process.on signal, do (signal) ->
-> p.kill signal
p.on 'exit', (code) -> process.exit codePrint the --help usage message and exit. Deprecated switches are not
shown.
usage = ->
printLine optionParser.help()Print the --version message and exit.
version = ->
printLine "CoffeeScript version #{CoffeeScript.VERSION}"