mirror of
https://github.com/jashkenas/coffeescript.git
synced 2026-02-17 11:01:25 -05:00
127 lines
4.3 KiB
CoffeeScript
127 lines
4.3 KiB
CoffeeScript
posix: require 'posix'
|
|
path: require 'path'
|
|
coffee: require 'coffee-script'
|
|
optparse: require('./../../vendor/optparse-js/src/optparse')
|
|
|
|
BANNER: '''
|
|
coffee compiles CoffeeScript source files into JavaScript.
|
|
|
|
Usage:
|
|
coffee path/to/script.coffee
|
|
'''
|
|
|
|
SWITCHES: [
|
|
['-i', '--interactive', 'run an interactive CoffeeScript REPL']
|
|
['-r', '--run', 'compile and run a CoffeeScript']
|
|
['-o', '--output [DIR]', 'set the directory for compiled JavaScript']
|
|
['-w', '--watch', 'watch scripts for changes, and recompile']
|
|
['-p', '--print', 'print the compiled JavaScript to stdout']
|
|
['-l', '--lint', 'pipe the compiled JavaScript through JSLint']
|
|
['-e', '--eval', 'compile a cli scriptlet or read from stdin']
|
|
['-t', '--tokens', 'print the tokens that the lexer produces']
|
|
[ '--tree', 'print the parse tree that Jison produces']
|
|
['-n', '--no-wrap', 'raw output, no function safety wrapper']
|
|
['-g', '--globals', 'attach all top-level variables as globals']
|
|
['-v', '--version', 'display CoffeeScript version']
|
|
['-h', '--help', 'display this help message']
|
|
]
|
|
|
|
WATCH_INTERVAL: 0.5
|
|
|
|
options: {}
|
|
sources: []
|
|
option_parser: null
|
|
|
|
# The CommandLine handles all of the functionality of the `coffee` utility.
|
|
exports.run: ->
|
|
parse_options()
|
|
launch_repl() if options.interactive
|
|
usage() unless sources.length
|
|
compile_scripts()
|
|
this
|
|
|
|
# The "--help" usage message.
|
|
usage: ->
|
|
puts '\n' + option_parser.toString() + '\n'
|
|
process.exit 0
|
|
|
|
# The "--version" message.
|
|
version: ->
|
|
puts "CoffeeScript version " + coffee.VERSION
|
|
process.exit 0
|
|
|
|
# Compile a single source file to JavaScript.
|
|
compile: (script, source) ->
|
|
source ||= 'error'
|
|
options: {}
|
|
options.no_wrap: true if options.no_wrap
|
|
options.globals: true if options.globals
|
|
try
|
|
CoffeeScript.compile(script, options)
|
|
catch error
|
|
process.stdio.writeError(source + ': ' + error.toString())
|
|
process.exit 1 unless options.watch
|
|
null
|
|
|
|
# Compiles the source CoffeeScript, returning the desired JavaScript, tokens,
|
|
# or JSLint results.
|
|
compile_scripts: ->
|
|
return unless source: sources.shift()
|
|
opts: options
|
|
posix.cat(source).addCallback (code) ->
|
|
if opts.tokens then puts tokenize(code)
|
|
else if opts.tree then puts coffee.tree(code).toString()
|
|
else
|
|
js: coffee.compile code
|
|
if opts.run then eval js
|
|
else if opts.print then puts js
|
|
else if opts.lint then lint js
|
|
else write_js source, coffee.compile code
|
|
compile_scripts()
|
|
|
|
# Write out a JavaScript source file with the compiled code.
|
|
write_js: (source, js) ->
|
|
filename: path.basename(source, path.extname(source)) + '.js'
|
|
dir: options.output or path.dirname(source)
|
|
js_path: path.join dir, filename
|
|
posix.open(js_path, process.O_CREAT | process.O_WRONLY | process.O_TRUNC, parseInt('0755', 8)).addCallback (fd) ->
|
|
posix.write(fd, js)
|
|
|
|
# Pretty-print the token stream.
|
|
tokenize: (code) ->
|
|
strings: coffee.tokenize(code).map (token) ->
|
|
'[' + token[0] + ' ' + token[1].toString().replace(/\n/, '\\n') + ']'
|
|
strings.join(' ')
|
|
|
|
# Pipe compiled JS through JSLint (requires a working 'jsl' command).
|
|
lint: (js) ->
|
|
jsl: process.createChildProcess('jsl', ['-nologo', '-stdin'])
|
|
jsl.addListener 'output', (result) ->
|
|
puts result.replace(/\n/g, '') if result
|
|
jsl.addListener 'error', (result) ->
|
|
puts result if result
|
|
jsl.write js
|
|
jsl.close()
|
|
|
|
# Use OptionParser for all the options.
|
|
parse_options: ->
|
|
opts: options: {}
|
|
oparser: option_parser: new optparse.OptionParser SWITCHES
|
|
oparser.banner: BANNER
|
|
oparser.add: oparser['on']
|
|
|
|
oparser.add 'interactive', -> opts.interactive: true
|
|
oparser.add 'run', -> opts.run: true
|
|
oparser.add 'output', (n, dir) -> opts.output: dir
|
|
oparser.add 'watch', -> opts.watch: true
|
|
oparser.add 'print', -> opts.print: true
|
|
oparser.add 'lint', -> opts.lint: true
|
|
oparser.add 'eval', -> opts.eval: true
|
|
oparser.add 'tokens', -> opts.tokens: true
|
|
oparser.add 'tree', -> opts.tree: true
|
|
oparser.add 'help', => usage()
|
|
oparser.add 'version', => version()
|
|
|
|
paths: oparser.parse(process.ARGV)
|
|
sources: paths[2...paths.length]
|