repl.coffee

fs = require 'fs'
path = require 'path'
vm = require 'vm'
nodeREPL = require 'repl'
CoffeeScript = require './'
{merge, updateSyntaxError} = require './helpers'

sawSIGINT = no
transpile = no

replDefaults =
  prompt: 'coffee> ',
  historyFile: do ->
    historyPath = process.env.XDG_CACHE_HOME or process.env.HOME
    path.join historyPath, '.coffee_history' if historyPath
  historyMaxInputSize: 10240
  eval: (input, context, filename, cb) ->

    input = input.replace /\uFF00/g, '\n'

    input = input.replace /^\(([\s\S]*)\n\)$/m, '$1'

    input = input.replace /^\s*try\s*{([\s\S]*)}\s*catch.*$/m, '$1'

    {Block, Assign, Value, Literal, Call, Code, Root} = require './nodes'

    try

      tokens = CoffeeScript.tokens input

      if tokens.length >= 2 and tokens[0].generated and
         tokens[0].comments?.length isnt 0 and "#{tokens[0][1]}" is '' and
         tokens[1][0] is 'TERMINATOR'
        tokens = tokens[2...]
      if tokens.length >= 1 and tokens[tokens.length - 1].generated and
         tokens[tokens.length - 1].comments?.length isnt 0 and "#{tokens[tokens.length - 1][1]}" is ''
        tokens.pop()

      referencedVars = (token[1] for token in tokens when token[0] is 'IDENTIFIER')

      ast = CoffeeScript.nodes(tokens).body

      ast = new Block [new Assign (new Value new Literal '__'), ast, '=']

      ast     = new Code [], ast
      isAsync = ast.isAsync

      ast    = new Root new Block [new Call ast]
      js     = ast.compile {bare: yes, locals: Object.keys(context), referencedVars, sharedScope: yes}
      if transpile
        js = transpile.transpile(js, transpile.options).code

        js = js.replace /^"use strict"|^'use strict'/, ''
      result = runInContext js, context, filename

      if isAsync
        result.then (resolvedResult) ->
          cb null, resolvedResult unless sawSIGINT
        sawSIGINT = no
      else
        cb null, result
    catch err

      updateSyntaxError err, input
      cb err

runInContext = (js, context, filename) ->
  if context is global
    vm.runInThisContext js, filename
  else
    vm.runInContext js, context, filename

addMultilineHandler = (repl) ->
  {inputStream, outputStream} = repl

  origPrompt = repl._prompt ? repl.prompt

  multiline =
    enabled: off
    initialPrompt: origPrompt.replace /^[^> ]*/, (x) -> x.replace /./g, '-'
    prompt: origPrompt.replace /^[^> ]*>?/, (x) -> x.replace /./g, '.'
    buffer: ''

  nodeLineListener = repl.listeners('line')[0]
  repl.removeListener 'line', nodeLineListener
  repl.on 'line', (cmd) ->
    if multiline.enabled
      multiline.buffer += "#{cmd}\n"
      repl.setPrompt multiline.prompt
      repl.prompt true
    else
      repl.setPrompt origPrompt
      nodeLineListener cmd
    return

  inputStream.on 'keypress', (char, key) ->
    return unless key and key.ctrl and not key.meta and not key.shift and key.name is 'v'
    if multiline.enabled

      unless multiline.buffer.match /\n/
        multiline.enabled = not multiline.enabled
        repl.setPrompt origPrompt
        repl.prompt true
        return

      return if repl.line? and not repl.line.match /^\s*$/

      multiline.enabled = not multiline.enabled
      repl.line = ''
      repl.cursor = 0
      repl.output.cursorTo 0
      repl.output.clearLine 1

      multiline.buffer = multiline.buffer.replace /\n/g, '\uFF00'
      repl.emit 'line', multiline.buffer
      multiline.buffer = ''
    else
      multiline.enabled = not multiline.enabled
      repl.setPrompt multiline.initialPrompt
      repl.prompt true
    return

addHistory = (repl, filename, maxSize) ->
  lastLine = null
  try

    stat = fs.statSync filename
    size = Math.min maxSize, stat.size

    readFd = fs.openSync filename, 'r'
    buffer = Buffer.alloc size
    fs.readSync readFd, buffer, 0, size, stat.size - size
    fs.closeSync readFd

    repl.history = buffer.toString().split('\n').reverse()

    repl.history.pop() if stat.size > maxSize

    repl.history.shift() if repl.history[0] is ''
    repl.historyIndex = -1
    lastLine = repl.history[0]

  fd = fs.openSync filename, 'a'

  repl.addListener 'line', (code) ->
    if code and code.length and code isnt '.history' and code isnt '.exit' and lastLine isnt code

      fs.writeSync fd, "#{code}\n"
      lastLine = code

  repl.on 'SIGINT', -> sawSIGINT = yes
  repl.on 'exit', -> fs.closeSync fd

  repl.commands[getCommandId(repl, 'history')] =
    help: 'Show command history'
    action: ->
      repl.outputStream.write "#{repl.history[..].reverse().join '\n'}\n"
      repl.displayPrompt()

getCommandId = (repl, commandName) ->

  commandsHaveLeadingDot = repl.commands['.help']?
  if commandsHaveLeadingDot then ".#{commandName}" else commandName

module.exports =
  start: (opts = {}) ->
    [major, minor, build] = process.versions.node.split('.').map (n) -> parseInt(n, 10)

    if major < 6
      console.warn "Node 6+ required for CoffeeScript REPL"
      process.exit 1

    CoffeeScript.register()
    process.argv = ['coffee'].concat process.argv[2..]
    if opts.transpile
      transpile = {}
      try
        transpile.transpile = require('@babel/core').transform
      catch
        try
          transpile.transpile = require('babel-core').transform
        catch
          console.error '''
            To use --transpile with an interactive REPL, @babel/core must be installed either in the current folder or globally:
              npm install --save-dev @babel/core
            or
              npm install --global @babel/core
            And you must save options to configure Babel in one of the places it looks to find its options.
            See https://coffeescript.org/#transpilation
          '''
          process.exit 1
      transpile.options =
        filename: path.resolve process.cwd(), '<repl>'

      Module = require 'module'
      originalModuleLoad = Module::load
      Module::load = (filename) ->
        @options = transpile: transpile.options
        originalModuleLoad.call @, filename
    opts = merge replDefaults, opts
    repl = nodeREPL.start opts
    runInContext opts.prelude, repl.context, 'prelude' if opts.prelude
    repl.on 'exit', -> repl.outputStream.write '\n' if not repl.closed
    addMultilineHandler repl
    addHistory repl, opts.historyFile, opts.historyMaxInputSize if opts.historyFile

    repl.commands[getCommandId(repl, 'load')].help = 'Load code from a file into this REPL session'
    repl