Cakefile

fs            = require 'fs'
path          = require 'path'
CoffeeScript  = require './lib/coffee-script'
{spawn, exec} = require 'child_process'
helpers       = require './lib/coffee-script/helpers'

# ANSI Terminal Colors.
bold = red = green = reset = ''
unless process.env.NODE_DISABLE_COLORS
  bold  = '\x1B[0;1m'
  red   = '\x1B[0;31m'
  green = '\x1B[0;32m'
  reset = '\x1B[0m'

# Built file header.
header = """
  /**
   * IcedCoffeeScript Compiler v#{CoffeeScript.VERSION}
   * http://iced-coffee-script.github.io/iced-coffee-script
   *
   * Copyright 2011, Jeremy Ashkenas, Maxwell Krohn
   * Released under the MIT License
   */
"""

# Build the CoffeeScript language from source.
build = (cb) ->
  files = fs.readdirSync 'src'
  files = ('src/' + file for file in files when file.match(/\.(lit)?coffee$/))
  run ['-c', '-o', 'lib/coffee-script', '-I', 'none'].concat(files), cb

# Run a CoffeeScript through our node/coffee interpreter.
run = (args, cb) ->
  proc =         spawn 'node', ['bin/coffee'].concat(args)
  proc.stderr.on 'data', (buffer) -> console.log buffer.toString()
  proc.on        'exit', (status) ->
    process.exit(1) if status != 0
    cb() if typeof cb is 'function'

# Log a message with a color.
log = (message, color, explanation) ->
  console.log color + message + reset + ' ' + (explanation or '')

option '-p', '--prefix [DIR]', 'set the installation prefix for `cake install`'

task 'install', 'install CoffeeScript into /usr/local (or --prefix)', (options) ->
  base = options.prefix or '/usr/local'
  lib  = "#{base}/lib/coffee-script"
  bin  = "#{base}/bin"
  node = "~/.node_libraries/coffee-script"
  console.log   "Installing CoffeeScript to #{lib}"
  console.log   "Linking to #{node}"
  console.log   "Linking 'coffee' to #{bin}/coffee"
  exec([
    "mkdir -p #{lib} #{bin}"
    "cp -rf bin lib LICENSE README package.json src #{lib}"
    "ln -sfn #{lib}/bin/coffee #{bin}/coffee"
    "ln -sfn #{lib}/bin/cake #{bin}/cake"
    "mkdir -p ~/.node_libraries"
    "ln -sfn #{lib}/lib/coffee-script #{node}"
  ].join(' && '), (err, stdout, stderr) ->
    if err then console.log stderr.trim() else log 'done', green
  )


task 'build', 'build the CoffeeScript language from source', build

task 'build:full', 'rebuild the source twice, and run the tests', ->
  build ->
    build ->
      csPath = './lib/coffee-script'
      csDir  = path.dirname require.resolve csPath

      for mod of require.cache when csDir is mod[0 ... csDir.length]
        delete require.cache[mod]

      unless runTests require csPath
        process.exit 1


task 'build:parser', 'rebuild the Jison parser (run build first)', ->
  helpers.extend global, require('util')
  require 'jison'
  parser = require('./lib/coffee-script/grammar').parser
  fs.writeFile 'lib/coffee-script/parser.js', parser.generate()


task 'build:ultraviolet', 'build and install the Ultraviolet syntax highlighter', ->
  exec 'plist2syntax ../coffee-script-tmbundle/Syntaxes/CoffeeScript.tmLanguage', (err) ->
    throw err if err
    exec 'sudo mv coffeescript.yaml /usr/local/lib/ruby/gems/1.8/gems/ultraviolet-0.10.2/syntax/coffeescript.syntax'

jsGenLib = (name) ->
  """
      require['./#{name}'] = (function() {
        var exports = {}, module = { exports : exports };
        #{fs.readFileSync "lib/coffee-script/#{name}.js"}
        return module.exports;
      })();
  """
    
jsMinify = (code) ->
  unless process.env.MINIFY is 'false'
    {code} = require('uglify-js').minify code, fromString: true
  code

jsWrapCode = (code, klass, req, assigns) -> 
  p = []
  p.push """
    (function(root) {
      var #{klass} = function() {
        function require(path){ return require[path]; }
        #{code}
        return require['./#{req}'];
      }();
      if (typeof define === 'function' && define.amd) {"""
        
  for x in assigns
    p.push "      define(function() { return #{x[1]}; });"
  
  p.push """    } else {    """

  for x in assigns
    p.push "      root.#{x[0]} = #{x[1]};"
  
  p.push "    }"
  p.push " }(this));"
  
  p.join '\n'
  
 
task 'build:browser', 'rebuild the merged script for inclusion in the browser', ->
  code = ''
  for name in ['helpers', 'rewriter', 'lexer', 'parser', 'iced', 'scope', 'nodes', 'sourcemap', 'coffee-script', 'browser', 'icedlib']
    code += jsGenLib name

  code = jsWrapCode code, "CoffeeScript", "coffee-script", [
    [ 'CoffeeScript' , 'CoffeeScript' ],
    [ 'iced', 'CoffeeScript.iced' ]
  ]
  code = jsMinify code
  fs.writeFileSync 'extras/coffee-script.js', header + '\n' + code

  code = jsGenLib 'iced'
  code = jsWrapCode code, 'Iced', 'iced', [
    [ 'iced', 'Iced.runtime' ]
  ]
  code = jsMinify code
  fs.writeFileSync 'extras/coffee-script-iced.js', header + '\n' + code

  code = (jsGenLib 'iced') + (jsGenLib 'icedlib')
  code = jsWrapCode code, 'Icedlib', 'icedlib', [
    [ 'icedlib', 'Icedlib' ],
    [ 'iced', 'Icedlib.iced' ]
  ]
  code = jsMinify code
  fs.writeFileSync 'extras/coffee-script-iced-large.js', header + '\n' + code

  console.log "built ... running browser tests:"
  invoke 'test:browser'

task 'doc:site', 'watch and continually rebuild the documentation for the website', ->
  exec 'rake doc', (err) ->
    throw err if err

task 'doc:source', 'rebuild the internal documentation', ->
  exec 'docco src/*.*coffee && cp -rf docs documentation && rm -r docs', (err) ->
    throw err if err


task 'doc:underscore', 'rebuild the Underscore.coffee documentation page', ->
  exec 'docco examples/underscore.coffee && cp -rf docs documentation && rm -r docs', (err) ->
    throw err if err

task 'bench', 'quick benchmark of compilation time', ->
  {Rewriter} = require './lib/coffee-script/rewriter'
  sources = ['coffee-script', 'grammar', 'helpers', 'lexer', 'nodes', 'rewriter']
  coffee  = sources.map((name) -> fs.readFileSync "src/#{name}.coffee").join '\n'
  litcoffee = fs.readFileSync("src/scope.litcoffee").toString()
  fmt    = (ms) -> " #{bold}#{ "   #{ms}".slice -4 }#{reset} ms"
  total  = 0
  now    = Date.now()
  time   = -> total += ms = -(now - now = Date.now()); fmt ms
  tokens = CoffeeScript.tokens coffee, rewrite: no
  littokens = CoffeeScript.tokens litcoffee, rewrite: no, literate: yes
  tokens = tokens.concat(littokens)
  console.log "Lex    #{time()} (#{tokens.length} tokens)"
  tokens = new Rewriter().rewrite tokens
  console.log "Rewrite#{time()} (#{tokens.length} tokens)"
  nodes  = CoffeeScript.nodes tokens
  console.log "Parse  #{time()}"
  js     = nodes.compile bare: yes
  console.log "Compile#{time()} (#{js.length} chars)"
  console.log "total  #{ fmt total }"


# Run the CoffeeScript test suite.
runTests = (CoffeeScript) ->
  startTime   = Date.now()
  currentFile = null
  passedTests = 0
  failures    = []
  attemptedTests = 0

  global[name] = func for name, func of require 'assert'

  # Convenience aliases.
  global.CoffeeScript = CoffeeScript
  global.Repl = require './lib/coffee-script/repl'

  # Our test helper function for delimiting different test cases.
  global.test = (description, fn) ->
    try
      ++attemptedTests
      fn.test = {description, currentFile}
      fn.call(fn)
      ++passedTests
    catch e
      failures.push
        filename: currentFile
        error: e
        description: description if description?
        source: fn.toString() if fn.toString?

  # An async testing primitive
  global.atest = (description, fn) ->
    ++attemptedTests
    fn.test = { description, currentFile }
    fn.call fn, (ok, e) =>
      if ok
        ++passedTests
      else
        e.description = description if description?
        e.source      = fn.toString() if fn.toString?
        failures.push filename : currentFile, error : e

  # See http://wiki.ecmascript.org/doku.php?id=harmony:egal
  egal = (a, b) ->
    if a is b
      a isnt 0 or 1/a is 1/b
    else
      a isnt a and b isnt b

  # A recursive functional equivalence helper; uses egal for testing equivalence.
  arrayEgal = (a, b) ->
    if egal a, b then yes
    else if a instanceof Array and b instanceof Array
      return no unless a.length is b.length
      return no for el, idx in a when not arrayEgal el, b[idx]
      yes

  global.eq      = (a, b, msg) -> ok egal(a, b), msg ? "Expected #{a} to equal #{b}"
  global.arrayEq = (a, b, msg) -> ok arrayEgal(a,b), msg ? "Expected #{a} to deep equal #{b}"

  # When all the tests have run, collect and print errors.
  # If a stacktrace is available, output the compiled function source.
  process.on 'exit', ->
    time = ((Date.now() - startTime) / 1000).toFixed(2)
    message = "passed #{passedTests} tests in #{time} seconds#{reset}"
    log("Only #{passedTests} of #{attemptedTests} came back; some went missing!", red) unless passedTests == attemptedTests
    return log(message, green) unless failures.length
    log "failed #{failures.length} and #{message}", red
    for fail in failures
      {error, filename, description, source}  = fail
      console.log ''
      log "  #{description}", red if description
      log "  #{error.stack}", red
      console.log "  #{source}" if source
    return

  # Run every test in the `test` folder, recording failures.
  files = fs.readdirSync 'test'
  for file in files when helpers.isCoffee file
    console.log "XX #{file}"
    literate = helpers.isLiterate file
    currentFile = filename = path.join 'test', file
    code = fs.readFileSync filename
    runtime = if file is 'iced.coffee' then 'inline' else 'none'
    try
      CoffeeScript.run code.toString(), {filename, literate, runtime}
    catch error
      failures.push {filename, error}
  return !failures.length

task 'test', 'run the CoffeeScript language test suite', ->
  runTests CoffeeScript

task 'test:browser', 'run the test suite against the merged browser script', ->
  source = fs.readFileSync 'extras/coffee-script.js', 'utf-8'
  result = {}
  global.testingBrowser = yes
  (-> eval source).call result
  runTests result.CoffeeScript