command.coffee

fs:           require 'fs'
path:         require 'path'
optparse:     require './optparse'
CoffeeScript: require './coffee-script'

BANNER: '''
  coffee compiles CoffeeScript source files into JavaScript.

  Usage:
    coffee path/to/script.coffee
        '''

SWITCHES: [
  ['-c', '--compile',       'compile to JavaScript and save as .js files']
  ['-i', '--interactive',   'run an interactive CoffeeScript REPL']
  ['-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']
  ['-s', '--stdio',         'listen for and compile scripts over stdio']
  ['-e', '--eval',          'compile a string from the command line']
  [      '--no-wrap',       'compile without the top-level function wrapper']
  ['-t', '--tokens',        'print the tokens that the lexer produces']
  ['-n', '--nodes',         'print the parse tree that Jison produces']
  ['-v', '--version',       'display CoffeeScript version']
  ['-h', '--help',          'display this help message']
]

options: {}
sources: []
option_parser: null

exports.run: ->
  parse_options()
  return usage()                              if options.help
  return version()                            if options.version
  return require './repl'                     if options.interactive
  return compile_stdio()                      if options.stdio
  return compile_script 'console', sources[0] if options.eval
  return usage()                              unless sources.length
  separator: sources.indexOf '--'
  flags: []
  if separator >= 0
    flags: sources[(separator + 1)...sources.length]
    sources: sources[0...separator]
  process.ARGV: process.argv: flags
  watch_scripts() if options.watch
  compile_scripts()

compile_scripts: ->
  compile: (source) ->
    path.exists source, (exists) ->
      throw new Error "File not found: $source" unless exists
      fs.readFile source, (err, code) -> compile_script(source, code)
  compile(source) for source in sources

compile_script: (source, code) ->
  o: options
  code_opts: compile_options source
  try
    if      o.tokens      then print_tokens CoffeeScript.tokens code
    else if o.nodes       then puts CoffeeScript.nodes(code).toString()
    else if o.run         then CoffeeScript.run code, code_opts
    else
      js: CoffeeScript.compile code, code_opts
      if o.print          then process.stdio.write js
      else if o.compile   then write_js source, js
      else if o.lint      then lint js
  catch err
    if o.watch            then puts err.message else throw err

compile_stdio: ->
  code: ''
  process.stdio.open()
  process.stdio.addListener 'data', (string) ->
    code: + string if string
  process.stdio.addListener 'close', ->
    compile_script 'stdio', code

watch_scripts: ->
  watch: (source) ->
    fs.watchFile source, {persistent: true, interval: 500}, (curr, prev) ->
      return if curr.mtime.getTime() is prev.mtime.getTime()
      fs.readFile source, (err, code) -> compile_script(source, code)
  watch(source) for source in sources

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
  fs.writeFile js_path, js

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()

print_tokens: (tokens) ->
  strings: for token in tokens
    [tag, value]: [token[0], token[1].toString().replace(/\n/, '\\n')]
    "[$tag $value]"
  puts strings.join(' ')

parse_options: ->
  option_parser: new optparse.OptionParser SWITCHES, BANNER
  o: options:    option_parser.parse(process.argv)
  options.run:   not (o.compile or o.print or o.lint)
  options.print: !!  (o.print or (o.eval or o.stdio and o.compile))
  sources:       options.arguments[2...options.arguments.length]

compile_options: (source) ->
  o: {source: source}
  o['no_wrap']: options['no-wrap']
  o

usage: ->
  puts option_parser.help()
  process.exit 0

version: ->
  puts "CoffeeScript version ${CoffeeScript.VERSION}"
  process.exit 0