makura.coffee

cradle: require 'cradle'
sys: require 'sys'

p: () ->
  for arg in arguments
    sys.puts(sys.inspect(arg, false, 5))

class ModelInstance
  constructor: (doc) ->
    @doc: doc

class ModelTemplate
  constructor: (model, name) ->
    @model: model
    @name: name
    @proto: {}

  design: (head, tail) ->
    head.apply designDoc: {}
    for name, doc in designDoc
      for key in doc
        @proto[key]: ->
          this[key]

    @model.db.insert "_design/${@name}", designDoc, tail

  create: (doc, callback) ->
    doc.type ||= @name
    db: @model.db
    db.insert.apply db, arguments

  view: (path, options, callback) ->
    path: "${@name}/${path}"
    self: this
    @model.db.view path, options, (err, docs) ->
      callback(err, docs.rows.map (doc) ->
        doc
      )

class Model
  constructor: (conn, name) ->
    @conn: conn
    @name: name
    @db: conn.database(name)

  derive: (name) ->
    template: new ModelTemplate(this, name)

  destroy: (callback) ->
    @db.destroy(callback)

  create: (callback) ->
    @db.create(callback)

  reset: (callback) ->
    self: this
    self.destroy ->
      self.create callback

  info: (callback) ->
    @db.info callback

conn: new cradle.Connection('localhost', 5984, { cache: true, raw: false })

model: new Model(conn, 'disjoint')
model.reset ->
  User: model.derive 'User'
  User.design ->
    @by_name: {
      map: (doc) ->
        emit doc.name, doc if doc.type is 'User'
    }
  , ->
    User.create {name: 'manveru'}, (err, doc) ->
      p {err: err}
      p {doc: doc}
      User.view 'by_name', {key: 'manveru'}, (err, docs) ->
        p {err: err}
        p {docs: docs}