coffeeapp.coffee

{existsSync, join, extname} = require 'path'
{mkdirSync, readdirSync, writeFileSync, readFileSync, statSync} = require 'fs'
{compile} = require 'coffee-script'
{exec}  = require 'child_process'
{print, gets} = require 'util'
{log} = console

commandWraps = [
  {
    name: 'push',
    type: 'before',
    callback: -> grindCoffee()
  },
  {
    name: 'help',
    type: 'after',
    desc: '     show this message',
    callback: -> help()
  },
  {
    name: 'cgenerate',
    type: 'before',
    desc: '[ view | list | show | filter ] generate .coffee versions',
    callback: -> generate()
  },
  {
    name: 'destroy',
    type: 'before',
    desc: '  [ view | list | show | filter ] destroy (remove directory/files also .js files).',
    callback: -> destroy()
  },
  {
    name: 'prepare',
    type: 'before',
    desc: '  prepare (.gitignore...)',
    callback: -> prepare()
  },
  {
    name: 'clean',
    type: 'before',
    desc: '    remove .releases directory'
    callback: -> clean()
  }
]

gitIgnore = '''
.DS_Store
.couchapprc
.releases/*
.releases/**/*
'''

mapCoffee = '''
(doc) ->
  ...
'''

reduceCoffee = '''
(keys, values, rereduce) ->
  ...
'''

listCoffee = '''
(head, req) ->
  ...
'''

showCoffee = '''
(doc, req) ->
  ...
'''

filterCoffee = '''
(doc, req) ->
  ...
'''

getVersion = ->
  readFileSync(join(__dirname, '..', 'package.json')).toString().match(/"version"\s*:\s*"([\d.]+)"/)[1]

showGreatings = ->

  log "CoffeeApp (#{getVersion()}) - simple coffee-script wrapper for CouchApp (http://couchapp.org)"
  log 'http://github.com/andrzejsliwa/coffeeapp\n'

padTwo = (number) ->
  result = if number < 10 then '0' else ''
  "#{result}#{number}"

getTimestamp = ->
  date = new Date
  date.getFullYear() + padTwo(date.getMonth() + 1) +
  padTwo(date.getDate()) + padTwo(date.getHours() + 1) +
  padTwo(date.getMinutes() + 1) + padTwo(date.getSeconds() + 1)

printOutput = (error, stdout, stderr) ->
  log stdout if stdout && stdout.length > 0
  log stderr if stderr && stderr.length > 0
  if error != null
    log "exec error: #{error}"

processRecursive = (currentDir, destination) ->
  fileList = readdirSync currentDir
  isError = false
  for fileName in fileList
    filePath = join currentDir, fileName
    destFilePath = join destination, filePath
    if statSync(filePath).isDirectory()
      unless fileName[0] == '.'
        mkdirSync destFilePath, 0700
        isError = true unless processRecursive filePath, destination
    else

      if extname(filePath) == '.coffee'
        log " * processing #{filePath}..."
        try
          writeFileSync destFilePath.replace(/\.coffee$/, '.js'),
            compile(readFileSync(filePath, 'utf8'), noWrap: yes).replace(/^\(/,'').replace(/\);$/, ''), 'utf8'
        catch error
          log "Compilation Error: #{error.message}\n"
          isError = true

      else
        writeFileSync destFilePath, readFileSync(filePath, 'binary'), 'binary'
  !isError

grindCoffee = ->
  log "Wrapping 'push' of couchapp"
  releasesDir = '.releases'
  unless existsSync releasesDir
    log "initialize #{releasesDir} directory"
    mkdirSync releasesDir, 0700
  releasePath = join releasesDir, getTimestamp()
  log "preparing #{releasePath} release:"
  mkdirSync releasePath, 0700
  if processRecursive '.', releasePath
    [options..., database] = process.argv[1..]
    options = (options || []).join ' '
    exec "couchapp push #{options} #{releasePath} #{database}", printOutput
    process.cwd()

help = ->
  log "Wrapping 'help' of couchapp\n"
  showGreatings()
  for command in commandWraps
    if command.desc
      log "#{command.name}        #{command.desc}"

generateFile = (path, template) ->
  log " * creating #{path}..."
  if existsSync path
    log "File #{path} already exist!"
  else
    writeFileSync path, template, 'utf8'

generate = -> operateOn('generate')
destroy = -> operateOn('destroy')

operateOn = (command) ->
  generator = process.argv[1]
  unless generator
    log "missing name of #{command} - [ view | list | show | filter ]"
    return
  name = process.argv[2]
  unless name
    log 'missing name of element'
    return
  print "Running #{generator} #{command}: "
  fun = switch generator
    when 'view'
      handleView
    when 'show'
      handleShow
    when 'list'
      handleList
    when 'filter'
      handleFilter
    else
      (_, _) -> log "unknown #{command}"
  log 'done.' if fun(command, name)

handleView = (method, name) ->
  unless existsSync 'views'
    mkdirSync 'views', 0700

  viewDirPath = "views/#{name}"
  [mapFilePath, reduceFilePath] = [join(viewDirPath, "map.coffee"), join(viewDirPath, "reduce.coffee")]
  switch method
    when 'generate'
      if existsSync viewDirPath
        log "directory '#{viewDirPath}' already exist!"
        false
      else
        mkdirSync viewDirPath, 0700
        generateFile mapFilePath, mapCoffee
        generateFile reduceFilePath, reduceCoffee
        true
    when 'destroy'
      if existsSync viewDirPath
        log "'#{viewDirPath}'."
        exec "rm -r #{viewDirPath}", printOutput
        true
      else
        log "there is no view '#{name}' ('#{viewDirPath}') !!!"
        false
    else
      throw 'unknown method'

handleFile = (method, folder, template, name) ->
  filePathCoffee = join folder, "#{name}.coffee"
  filePathJS = join folder, "#{name}.js"
  switch method
    when 'generate'
      unless existsSync folder
        mkdirSync folder, 0700
      generateFile filePathCoffee, template
      true
    when 'destroy'
      if existsSync filePathCoffee
        log "'#{filePathCoffee}'."
        exec "rm #{filePathCoffee}", printOutput
        true
      else if existsSync filePathJS
        log "'#{filePathJS}'."
        exec "rm #{filePathJS}", printOutput
        true
      else
        log "there is no '#{name}' ('#{filePathJS}' or '#{filePathCoffee}') !!!"
        false
    else
      throw 'unknown method'

handleShow = (method, name) -> handleFile(method, 'shows', showCoffee, name)
handleList = (method, name) -> handleFile(method, 'lists', listCoffee, name)
handleFilter = (method, name) -> handleFile(method, 'filters', filterCoffee, name)

clean = ->
  log "cleaning up:"
  log " * remove '.releases' ..."
  exec 'rm -r .releases'
  log "done."

prepare = ->
  log "preparing project:"
  generateFile '.gitignore', gitIgnore
  log "done."

handleCommand = (type) ->
  handled = false
  for cmd in commandWraps
    if cmd.type == type && cmd.name == process.argv[0]
      handled = true
      cmd.callback()
  handled

exports.run = ->
  showGreatings()
  unless handleCommand('before')

    options = process.argv.join(' ')
    log "Calling couchapp"

    exec "couchapp #{options}", (error, stdout, stderr) ->
      printOutput(error, stdout, stderr)
      handleCommand('after')