zappa.coffee

# **Zappa** is a [CoffeeScript](http://coffeescript.org) DSL-ish interface for building web apps on the
# [node.js](http://nodejs.org) runtime, integrating [express](http://expressjs.com), [socket.io](http://socket.io)
# and other best-of-breed libraries.

zappa = version: '0.3.3'

codename = 'The Gumbo Variations'

log = console.log
fs = require 'fs'
path = require 'path'
uuid = require 'node-uuid'
express = require 'express'
socketio = require 'socket.io'
uglify = require 'uglify-js'
minify = (js) ->
  ast = uglify.parser.parse(js)
  ast = uglify.uglify.ast_mangle(ast)
  ast = uglify.uglify.ast_squeeze(ast)
  uglify.uglify.gen_code(ast)


# Shallow copy attributes from `sources` (array of objects) to `recipient`.
# Does NOT overwrite attributes already present in `recipient`.
copy_data_to = (recipient, sources) ->
  for obj in sources
    for k, v of obj
      recipient[k] = v unless recipient[k]

# Keep inline views at the module level and namespaced by app id
# so that the monkeypatched express can look them up.
views = {}
viewhelpers = {}
# Monkeypatch express to support lookup of inline templates. Such is life.
express.View.prototype.__defineGetter__ 'exists', ->
  # Path given by zappa: /path/to/appid/foo.bar.
  
  # Try appid/foo.bar in memory.
  p = @path.replace @root + '/', ''
  id = p.split('/')[0]
  return true if views[p]

  # Try appid/foo in memory.
  p = p.replace(path.extname(p), '')
  return true if views[p]

  # Try /path/to/foo.bar in filesystem (normal express behaviour).
  p = @path.replace id + '/', ''
  try
    fs.statSync(p)
    return true
  catch err
    return false

express.View.prototype.__defineGetter__ 'contents', ->
  # Path given by zappa: /path/to/appid/foo.bar.

  # Try appid/foo.bar in memory.
  p = @path.replace @root + '/', ''
  id = p.split('/')[0]
  return views[p] if views[p]

  # Try appid/foo in memory.
  p = p.replace(path.extname(p), '')
  return views[p] if views[p]

  # Try /path/to/foo.bar in filesystem (normal express behaviour).
  p = @path.replace id + '/', ''
  fs.readFileSync p, 'utf8'

# Takes in a function and builds express/socket.io apps based on the rules contained in it.
zappa.app = (func) ->
  context = {id: uuid(), zappa, express}
  
  context.root = path.dirname(module.parent.filename)

  # Storage for user-provided stuff.
  # Views are kept at the module level.
  ws_handlers = {}
  helpers = {}
  postrenders = {}

  app = context.app = express.createServer()
  io = context.io = socketio.listen(app)

  # Tracks if the zappa middleware is already mounted (`@use 'zappa'`).
  zappa_used = no

  # Zappa's default settings.
  app.set 'view engine', 'html'
  replace_partials = (src, pf) ->
    return src.replace /@partial \w+/g, (match, pos, contents, s)->
      fn = match['@partial'.length+1..]
      pf(fn)

  app.register '.html',
    compile: (str, options)->
      return (locals)->
        str = str.replace(/@body/g, options.body) if options.body
        if options.initdata and not options.isPartial and not options.isLayout
          str = str.replace /_initdata/g, JSON.stringify(options.initdata)
        replace_partials(str, options.partial)

  # Sets default view dir to @root (`path.dirname(module.parent.filename)`).
  app.set 'views', path.join(context.root, '/views')

  for verb in ['get', 'post', 'put', 'del']
    do (verb) ->
      context[verb] = ->
        if arguments.length > 1
          route verb: verb, path: arguments[0], handler: arguments[1]
        else
          for k, v of arguments[0]
            route verb: verb, path: k, handler: v

  context.js = (obj) ->
    for k, v of obj
      js = String(v)
      js = minify(js) if app.settings['minify']
      route verb: 'get', path: k, handler: js, contentType: 'js'

  context.css = (obj) ->
    for k, v of obj
      css = String(v)
      route verb: 'get', path: k, handler: css, contentType: 'css'

  context.helper = (obj) ->
    for k, v of obj
      helpers[k] = v

  context.on = (obj) ->
    for k, v of obj
      ws_handlers[k] = v

  context.view = (obj) ->
    for k, v of obj
      views["#{context.id}/#{k}"] = v

  context.register = (obj) ->
    for k, v of obj
      app.register '.' + k, v

  context.set = (obj) ->
    for k, v of obj
      app.set k, v
      
  context.enable = ->
    app.enable i for i in arguments

  context.disable = ->
    app.disable i for i in arguments

  context.use = ->
    zappa_middleware =
      static: (p = path.join(context.root, '/public')) ->
        express.static(p)
      zappa: ->
        (req, res, next) ->
          send = (code) ->
            res.contentType 'js'
            res.send code
          next()

    use = (name, arg = null) ->
      zappa_used = yes if name is 'zappa'
      
      if zappa_middleware[name]
        app.use zappa_middleware[name](arg)
      else if typeof express[name] is 'function'
        app.use express[name](arg)
     
    for a in arguments
      switch typeof a
        when 'function' then app.use a
        when 'string' then use a
        when 'object' then use k, v for k, v of a
    
  context.configure = (p) ->
    if typeof p is 'function' then app.configure p
    else app.configure k, v for k, v of p
    
  context.settings = app.settings

  context.include = (p) ->
    sub = require path.join(context.root, p)
    sub.include.apply(context, [context])

  # Register a route with express.
  route = (r) ->
    qry = app.lookup[r.verb]( r.path)
    if qry.length > 0
      console.log "#{r.verb} #{r.path} exists! Replace it"
      app.remove[r.verb] r.path
    if typeof r.handler is 'string'
      app[r.verb] r.path, (req, res) ->
        res.contentType r.contentType if r.contentType?
        res.send r.handler
    else
      app[r.verb] r.path, (req, res, next) ->
        ctx =
          app: app
          settings: app.settings
          request: req
          query: req.query
          params: req.params
          body: req.body
          session: req.session
          response: res
          next: next
          send: -> res.send.apply res, arguments
          redirect: -> res.redirect.apply res, arguments
          render: ->
            if typeof arguments[0] isnt 'object'
              render.apply @, arguments
            else
              for k, v of arguments[0]
                render.apply @, [k, v]

        render = (args...) ->
          # Adds the app id to the view name so that the monkeypatched
          # express.View.exists and express.View.contents can lookup
          # this app's inline templates.
          args[0] = context.id + '/' + args[0]
        
          # Make sure the second arg is an object.
          args[1] ?= {}
          args.splice 1, 0, {} if typeof args[1] is 'function'
        
          if app.settings['databag']
            args[1].params = data
          # Just forward params to express.
          res.render.apply res, args

        for name, helper of helpers
          do (name, helper) ->
            ctx[name] = (args...) ->
              args.push ctx
              helper.apply ctx, args

        if app.settings['databag']
          data = {}
          copy_data_to data, [req.query, req.params, req.body]

        # Go!
        switch app.settings['databag']
          when 'this' then result = r.handler.apply(data, [ctx])
          when 'param' then result = r.handler.apply(ctx, [data])
          else result = r.handler.apply(ctx, [ctx])
        
        res.contentType(r.contentType) if r.contentType?
        if typeof result is 'string' then res.send result
        else return result
  
  # Register socket.io handlers.
  io.sockets.on 'connection', (socket) ->
    c = {}
    
    build_ctx = ->
      ctx =
        app: app
        io: io
        settings: app.settings
        socket: socket
        id: socket.id
        emit: ->
          if typeof arguments[0] isnt 'object'
            socket.emit.apply socket, arguments
          else
            for k, v of arguments[0]
              socket.emit.apply socket, [k, v]
        broadcast: ->
          if typeof arguments[0] isnt 'object'
            socket.broadcast.emit.apply socket.broadcast, arguments
          else
            for k, v of arguments[0]
              socket.broadcast.emit.apply socket.broadcast, [k, v]

      for name, helper of helpers
        do (name, helper) ->
          ctx[name] = ->
            helper.apply(ctx, arguments)
      ctx

    ctx = build_ctx()
    ws_handlers.connection.apply(ctx, [ctx]) if ws_handlers.connection?

    socket.on 'disconnect', ->
      ctx = build_ctx()
      ws_handlers.disconnect.apply(ctx, [ctx]) if ws_handlers.disconnect?

    for name, h of ws_handlers
      do (name, h) ->
        if name isnt 'connection' and name isnt 'disconnect'
          socket.on name, (data) ->
            ctx = build_ctx()
            ctx.data = data
            switch app.settings['databag']
              when 'this' then h.apply(data, [ctx])
              when 'param' then h.apply(ctx, [data])
              else h.apply(ctx, [ctx])

  # Go!
  func.apply(context, [context])

  context

# Takes a function and runs it as a zappa app. Optionally accepts a port number, and/or
# a hostname (any order). The hostname must be a string, and the port number must be
# castable as a number.
# Returns an object where `app` is the express server and `io` is the socket.io handle.
# Ex.:
#     require('zappa') -> get '/': 'hi'
#     require('zappa').run 80, -> get '/': 'hi'
#     require('zappa') -> 'domain.com', 80, -> get '/': 'hi'
zappa.run = ->
  host = null
  port = 3000
  root_function = null

  for a in arguments
    switch typeof a
      when 'string'
        if isNaN( (Number) a ) then host = a
        else port = (Number) a
      when 'number' then port = a
      when 'function' then root_function = a

  zapp = zappa.app(root_function)
  app = zapp.app

  if host then app.listen port, host
  else app.listen port

  log 'Express server listening on port %d in %s mode',
    app.address()?.port, app.settings.env

  log "SZappa #{zappa.version} \"#{codename}\" orchestrating the show"

  zapp



module.exports = zappa.run
module.exports.run = zappa.run
module.exports.app = zappa.app
module.exports.adapter = zappa.adapter
module.exports.version = zappa.version