Gorkfile

require! fs
require! './lib/gorilla'
require! path
let {exec} = require 'child_process'
let {string-repeat, pad-left, pad-right} = require './lib/utils'

option \uglify, "u", "Use UglifyJS2 to minify the result"
option \minify, null, "Minimize the use of unnecessary whitespace"
option \file, "f", "Build a specific file", "file"
option \prefix, null, "Path to install to (/usr/local by default)"
//option \js, null, "Compile to JavaScript (default)"

let get-lang(options) -> "js"

command \install, "Install GorillaScript to /usr/local or --prefix", #(options, cb)
  async! cb, filename-path <- fs.realpath __filename
  let install-path = options.prefix or "/usr/local"
  let bin = path.join install-path, "bin"
  let files = ["gorilla", "gork", "gjs-gorilla"]
  let cmds = [
    "mkdir -p $bin"
    ...for file in files
      "ln -sfn $(path.join filename-path, '..', 'bin', file) $bin/$file"
  ]
  exec cmds.join(" && "), #(err, stdout, stderr)
    if err
      console.error stderr.trim()
    else
      output "done\n"
    cb()

command \build, "Build GorillaScript from source", #(options, cb)
  async! cb, filename-path <- fs.realpath __filename
  let src-path = path.join(path.dirname(filename-path), "src")
  async! cb, mutable files <- fs.readdir src-path
  
  files := for filter file in files
    not r'prelude\.gs$'.test(file)
  if options.file
    let file-filter = options.file.split ","
    for file in file-filter
      if file not in files
        return cb "Cannot build unknown file: $file"
    files := for filter file in files
      file in file-filter
  
  if files.length == 0
    return cb("No files to build")
  
  async! cb <- gorilla.init(lang: get-lang(options))
  
  files.sort #(a, b) -> a.to-lower-case() <=> b.to-lower-case()
  let inputs = {}
  asyncfor(0) next, file in files
    async! cb, text <- fs.read-file path.join(src-path, file), "utf-8"
    inputs[file] := text
    next()
  
  let longest-name-len = for reduce file in files, current = 0; current max file.length
  
  output string-repeat(" ", longest-name-len)
  output "     parse     macro     reduce    translate compile $(if options.uglify then '  uglify  ' else '')|  total\n"
  let totals = {}
  let mutable total-time = 0
  let results = {}
  asyncfor err <- next, file in files
    let code = inputs[file]
    output "$(pad-right file & ':', longest-name-len + 1, ' ') "
    let start-file-time = Date.now()
    let progress = #(name, time)!
      totals[name] := (totals[name] or 0) + time
      output "  $(pad-left ((time / 1000_ms).to-fixed 3), 6, ' ') s"
    async err, compiled <- gorilla.compile code, { extends options, filename: file, progress: progress }
    if err?
      output "\n"
      return next(err)
    results[file] := compiled.code
    let end-file-time = Date.now()
    let file-time = end-file-time - start-file-time
    output " | $(pad-left ((file-time / 1000_ms).to-fixed 3), 6, ' ') s\n"
    total-time += file-time
    gc?()
    next()
  if err?
    return cb(err)
  if files.length > 1
    output string-repeat "-", longest-name-len + 53
    if options.uglify
      output string-repeat "-", 10
    output "+"
    output string-repeat "-", 9
    output "\n"
    output pad-right "total: ", longest-name-len + 2, ' '
    for part in [\parse, \macro-expand, \reduce, \translate, \compile, ...if options.uglify then [\uglify] else []]
      output "  $(pad-left ((totals[part] / 1000_ms).to-fixed 3), 6, ' ') s"
    output " | $(pad-left ((total-time / 1000_ms).to-fixed 3), 6, ' ') s\n"

  asyncfor(0) err <- next, file in files
    let compiled = results[file]
    let output-file = path.join "./lib", file.replace r"\.gs\$", ".js"
    async err <- fs.rename output-file, "$(output-file).bak"
    if err? and err.code != \ENOENT
      return next(err)
    async! next <- fs.write-file output-file, compiled, "utf8"
    next()
  cb(err)

command "build:full", "Build GorillaScript twice and run tests", #(options, cb)
  delete options.file
  async! cb <- invoke \build
  async! cb <- invoke \build
  async! cb <- invoke "build:browser"
  invoke \test, cb

command "build:browser", "Merge GorillaScript for use in the browser", #(options, cb)
  async! cb, filename-path <- fs.realpath __filename
  let lib-path = path.join(path.dirname(filename-path), "lib")
  let parts = []
  asyncfor next, file in ["utils", "jsutils", "types", "jsast", "parser", "jstranslator", "gorilla", "browser"]
    async! cb, text <- fs.read-file path.join(lib-path, file & ".js"), "utf8"
    parts.push """
      require['./$file'] = function () {
        var module = { exports: this };
        var exports = this;
        $(text.split("\n").join("\n  "))
        return module.exports;
      };
      """
    next()
  
  async! cb, mutable serialized-prelude <- gorilla.get-serialized-prelude("js")
  let mutable deserialized-prelude = JSON.parse serialized-prelude
  if options.uglify
    for k, v of deserialized-prelude
      if is-array! v
        for item, i in v
          if typeof item.code == \string and item.code.substring(0, 7) == "return "
            let mutable minified = require("uglify-js").minify(item.code.substring(7), from-string: true).code
            if minified.char-at(0) == "("
              minified := "return$minified"
            else
              minified := "return $minified"
            item.code := minified
  serialized-prelude := require('./lib/jsutils').to-JS-source deserialized-prelude, null, indent: 2
  let mutable code = """
    ;(function (root) {
      var GorillaScript = (function () {
        function require(path) {
          var has = Object.prototype.hasOwnProperty;
          if (has.call(require._cache, path)) {
            return require._cache[path];
          } else if (has.call(require, path)) {
            var func = require[path];
            delete require[path];
            return require._cache[path] = func.call({});
          }
        }
        require._cache = {};
        $(parts.join("\n").split("\n").join("\n  "))
        
        require("./browser");
        return require("./gorilla").withPrelude("js", $serialized-prelude);
      }());
      
      if (typeof define === "function" && define.amd) {
        define(function () { return GorillaScript; });
      } else {
        root.GorillaScript = GorillaScript;
      }
    }(this));
    """
  if options.uglify
    output "Built gorillascript.js, uglifying... "
    let start-time = new Date().get-time()
    code := require("uglify-js").minify(code, from-string: true).code
    output "$(((new Date().get-time() - start-time) / 1000_ms).to-fixed 3) s\n"
  else
    output "Built gorillascript.js\n"
  async! cb <- fs.write-file path.join(path.join(path.dirname(filename-path), "extras"), "gorillascript.js"), code, "utf8"
  cb()

command \test, "Run the GorillaScript test suite", #(options, cb)
  async! cb, filename-path <- fs.realpath __filename
  let tests-path = path.join(path.dirname(filename-path), "tests")
  async! cb, mutable files <- fs.readdir tests-path
  
  if options.file
    let file-filter = options.file.split ","
    for file in file-filter
      if file not in files
        return cb "Cannot build unknown file: $file"
    files := for filter file in files
      file in file-filter
  else
    files := for filter file in files
      path.extname(file) == ".gs"
  
  if files.length == 0
    return cb("No files to test")
  
  require! assert
  
  let sandbox = {}
  
  let mutable passed-tests = 0
  let add-sandbox(name, func)
    sandbox[name] := #(...args)
      let result = func ...args
      passed-tests += 1
      result

  for k of assert
    add-sandbox k, assert[k]

  let fail = assert.fail
  let success = add-sandbox \success, #->
  sandbox.eq := sandbox.strict-equal
  sandbox.run-once := #(value)
    let f = #
      if f.ran
        fail "called more than once"
      f.ran := true
      value
    f.ran := false
    f

  sandbox.gorilla := gorilla

  let mutable current-file = null
  let mutable num-failures = 0
  let add-failure(filename, error)!
    num-failures += 1
    if filename
      console.log filename
    if error.description
      console.log "  $(error.description)"
    if error.stack
      console.log error.stack
    else
      console.log String(error)
    if error.source
      console.log error.source

  sandbox.test := #(description, fn)!
    try
      fn.test := {
        description
        current-file
      }
      fn@ fn
    catch e
      try
        e.description := description
        e.source := fn.to-string()
      catch x
        void
      add-failure fn.test.filename, e

  let waiters = [[], []]
  let handle-waiters()
    let mutable found = true
    while found
      found := false
      for type in waiters
        if type.length
          found := true
          type.splice((Math.random() * type.length) \ 1, 1)[0]()
          break
  sandbox.async-test := #(description, fn)!
    fn.wait := #(get-value as ->, cb as ->)!
      waiters[0].push #-> fn.dont-wait(get-value, cb)
    fn.after := #(get-value as ->, cb as (null|Function))!
      waiters[1].push #-> fn.dont-wait(get-value, cb or #->)
    fn.dont-wait := #(get-value as ->, cb as ->)!
      let mutable result = void
      try
        result := get-value()
      catch e
        cb(e)
      else
        try
          cb(null, result)
        catch e
          e.description := description
          e.source := fn.to-string()
          add-failure fn.test.current-file, e
    sandbox.test description, fn

  let array-equal = #(a, b)
    if is-array! a
      unless is-array! b and a.length == b.length
        false
      else
        for every item, i in a
          array-equal item, b[i]
    else
      a is b

  sandbox.array-eq := #(a, b, msg)
    if not array-equal a, b
      let {inspect} = require('util')
      fail "$(JSON.stringify(a) or 'undefined') != $(JSON.stringify(b) or 'undefined')$(if msg then ': ' & msg else '')"
    else
      success()
  
  let inputs = {}
  asyncfor(0) err <- next, file, i in files
    unless r'\.gs$'i.test(file)
      return next()
    let filename = path.join tests-path, file
    async! next, code <- fs.read-file filename, "utf-8"
    inputs[file] := {code, filename}
    next()
  
  let longest-name-len = for reduce file in files, current = 0; current max file.length
  
  async! cb <- gorilla.init(lang: get-lang(options))
  
  output string-repeat(" ", longest-name-len)
  output "     parse     macro     reduce    translate compile $(if options.uglify then '  uglify  ' else '')  eval    |       total\n"
  
  let mutable total-time = 0
  let totals = {}
  asyncfor err <- next, file in files
    if inputs not ownskey file
      return next(new Error("Missing file input for $file"))
    let {code, filename} = inputs[file]

    let basename = path.basename filename
    output "$(pad-right basename & ':', longest-name-len + 1, ' ') "
    let start = Date.now()
    let mutable failure = false
    let start-time = Date.now()
    current-file := filename
    let progress = #(name, time)
      totals[name] := (totals[name] or 0) + time
      output "  $(pad-left ((time / 1000_ms).to-fixed 3), 6, ' ') s"
    async err, result <- gorilla.eval code.to-string(), { extends options, filename, sandbox, include-globals: true, no-prelude: options["no-prelude"], progress }
    if err?
      output "\n"
      failure := true
      add-failure basename, err

    handle-waiters()

    let end-time = Date.now()
    total-time += end-time - start-time

    output " | $(if failure then 'fail' else 'pass') $(pad-left ((end-time - start-time) / 1000_ms).to-fixed(3), 6, ' ') s\n"
    gc?()
    next()
  throw? err
  if files.length > 1
    output string-repeat "-", longest-name-len + 63
    if options.uglify
      output string-repeat "-", 10
    output "+"
    output string-repeat "-", 14
    output "\n"
    output pad-right "total: ", longest-name-len + 2, ' '
    for part in [\parse, \macro-expand, \reduce, \translate, \compile, ...if options.uglify then [\uglify] else [], \eval]
      output "  $(pad-left ((totals[part] / 1000_ms).to-fixed 3), 6, ' ') s"
    output " | "
    output if num-failures == 0 then "pass" else "fail"
    output " $(pad-left ((total-time / 1000_ms).to-fixed 3), 6, ' ') s\n"

  let message = "passed $passed-tests tests"
  if num-failures == 0
    console.log message
    cb(null)
  else
    console.log "failed $num-failures"
    set-timeout (# -> process.exit(1)), 100