fs = require 'fs'

path = require 'path'

helpers = require './helpers'

optparse = require './optparse'

CoffeeScript = require './'

{spawn, exec} = require 'child_process'

{EventEmitter} = require 'events'

readline = require 'readline'

useWinPathSep = path.sep is '\\'

helpers.extend CoffeeScript, new EventEmitter

printLine = (line) -> process.stdout.write line + '\n'

printWarn = (line) -> process.stderr.write line + '\n'

hidden = (file) -> /^\.|~$/.test file

BANNER = '''

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']

['-S', '--stream', 'stream stdin and run script on each line']

['-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']

]

opts = {}

sources = []

sourceCode = []

notSources = {}

watchedDirs = {}

optionParser = null

exports.buildCSOptionParser = buildCSOptionParser = ->

new optparse.OptionParser SWITCHES, BANNER

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 '''

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 or opts.stream

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

else

# An 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 '''

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 ';'

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 1

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 or opts.stream

CoffeeScript.register()

CoffeeScript.eval opts.prelude, task.options if opts.prelude

if opts.stream

streamInput task.input, task.options

else

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 1

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

streamInput = (input, options) ->

options.stream = yes

if not input

console.error '--stream requires a script to run via filename or -e'

process.exit 1

if opts.stdio

console.error '--stream and --stdio cannot be used together'

process.exit 1

rl = readline.createInterface

input: process.stdin

terminal: false

rl.on 'line', (line) ->

options.current_line = line

CoffeeScript.eval input, options

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.join

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 err

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 sourcesChanged

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']

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 + extension

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

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, compile

wait = (milliseconds, func) -> setTimeout func, milliseconds

timeLog = (message) ->

console.log "#{(new Date).toLocaleTimeString()} - #{message}"

printTokens = (tokens) ->

strings = for token in tokens

tag = token[0]

value = token[1].toString().replace(/\n/, '\\n')

"[#{tag} #{value}]"

printLine strings.join(' ')

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

compileOptions = (filename, base) ->

if opts.transpile

# The 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'

catch

# Give appropriate instructions depending on whether `coffee` was run

# locally or globally.

if require.resolve('.').indexOf(process.cwd()) is 0

console.error '''

else

console.error '''

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.transpile

# Babel 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

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"

answer

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 code

usage = ->

printLine optionParser.help()

version = ->

printLine "CoffeeScript version #{CoffeeScript.VERSION}"