event_cal 1.0

data/vendor/assets/javascripts/lib/spine.js.coffee

@@ -0,0 +1,535 @@
+Events =
+  bind: (ev, callback) ->
+    evs   = ev.split(' ')
+    calls = @hasOwnProperty('_callbacks') and @_callbacks or= {}
+
+    for name in evs
+      calls[name] or= []
+      calls[name].push(callback)
+    this
+
+  one: (ev, callback) ->
+    @bind ev, ->
+      @unbind(ev, arguments.callee)
+      callback.apply(this, arguments)
+
+  trigger: (args...) ->
+    ev = args.shift()
+
+    list = @hasOwnProperty('_callbacks') and @_callbacks?[ev]
+    return unless list
+
+    for callback in list
+      if callback.apply(this, args) is false
+        break
+    true
+
+  unbind: (ev, callback) ->
+    unless ev
+      @_callbacks = {}
+      return this
+
+    list = @_callbacks?[ev]
+    return this unless list
+
+    unless callback
+      delete @_callbacks[ev]
+      return this
+
+    for cb, i in list when cb is callback
+      list = list.slice()
+      list.splice(i, 1)
+      @_callbacks[ev] = list
+      break
+    this
+
+Log =
+  trace: true
+
+  logPrefix: '(App)'
+
+  log: (args...) ->
+    return unless @trace
+    if @logPrefix then args.unshift(@logPrefix)
+    console?.log?(args...)
+    this
+
+moduleKeywords = ['included', 'extended']
+
+class Module
+  @include: (obj) ->
+    throw new Error('include(obj) requires obj') unless obj
+    for key, value of obj when key not in moduleKeywords
+      @::[key] = value
+    obj.included?.apply(this)
+    this
+
+  @extend: (obj) ->
+    throw new Error('extend(obj) requires obj') unless obj
+    for key, value of obj when key not in moduleKeywords
+      @[key] = value
+    obj.extended?.apply(this)
+    this
+
+  @proxy: (func) ->
+    => func.apply(this, arguments)
+
+  proxy: (func) ->
+    => func.apply(this, arguments)
+
+  constructor: ->
+    @init?(arguments...)
+
+class Model extends Module
+  @extend Events
+
+  @records: {}
+  @crecords: {}
+  @attributes: []
+
+  @configure: (name, attributes...) ->
+    @className  = name
+    @records    = {}
+    @crecords   = {}
+    @attributes = attributes if attributes.length
+    @attributes and= makeArray(@attributes)
+    @attributes or=  []
+    @unbind()
+    this
+
+  @toString: -> "#{@className}(#{@attributes.join(", ")})"
+
+  @find: (id) ->
+    record = @records[id]
+    if !record and ("#{id}").match(/c-\d+/)
+      return @findCID(id)
+    throw new Error('Unknown record') unless record
+    record.clone()
+
+  @findCID: (cid) ->
+    record = @crecords[cid]
+    throw new Error('Unknown record') unless record
+    record.clone()
+
+  @exists: (id) ->
+    try
+      return @find(id)
+    catch e
+      return false
+
+  @refresh: (values, options = {}) ->
+    if options.clear
+      @records  = {}
+      @crecords = {}
+
+    records = @fromJSON(values)
+    records = [records] unless isArray(records)
+
+    for record in records
+      record.id           or= record.cid
+      @records[record.id]   = record
+      @crecords[record.cid] = record
+
+    @trigger('refresh', @cloneArray(records))
+    this
+
+  @select: (callback) ->
+    result = (record for id, record of @records when callback(record))
+    @cloneArray(result)
+
+  @findByAttribute: (name, value) ->
+    for id, record of @records
+      if record[name] is value
+        return record.clone()
+    null
+
+  @findAllByAttribute: (name, value) ->
+    @select (item) ->
+      item[name] is value
+
+  @each: (callback) ->
+    for key, value of @records
+      callback(value.clone())
+
+  @all: ->
+    @cloneArray(@recordsValues())
+
+  @first: ->
+    record = @recordsValues()[0]
+    record?.clone()
+
+  @last: ->
+    values = @recordsValues()
+    record = values[values.length - 1]
+    record?.clone()
+
+  @count: ->
+    @recordsValues().length
+
+  @deleteAll: ->
+    for key, value of @records
+      delete @records[key]
+
+  @destroyAll: ->
+    for key, value of @records
+      @records[key].destroy()
+
+  @update: (id, atts, options) ->
+    @find(id).updateAttributes(atts, options)
+
+  @create: (atts, options) ->
+    record = new @(atts)
+    record.save(options)
+
+  @destroy: (id, options) ->
+    @find(id).destroy(options)
+
+  @change: (callbackOrParams) ->
+    if typeof callbackOrParams is 'function'
+      @bind('change', callbackOrParams)
+    else
+      @trigger('change', callbackOrParams)
+
+  @fetch: (callbackOrParams) ->
+    if typeof callbackOrParams is 'function'
+      @bind('fetch', callbackOrParams)
+    else
+      @trigger('fetch', callbackOrParams)
+
+  @toJSON: ->
+    @recordsValues()
+
+  @fromJSON: (objects) ->
+    return unless objects
+    if typeof objects is 'string'
+      objects = JSON.parse(objects)
+    if isArray(objects)
+      (new @(value) for value in objects)
+    else
+      new @(objects)
+
+  @fromForm: ->
+    (new this).fromForm(arguments...)
+
+  # Private
+
+  @recordsValues: ->
+    result = []
+    for key, value of @records
+      result.push(value)
+    result
+
+  @cloneArray: (array) ->
+    (value.clone() for value in array)
+
+  @idCounter: 0
+
+  @uid: (prefix = '') ->
+    uid = prefix + @idCounter++
+    uid = @uid(prefix) if @exists(uid)
+    uid
+
+  # Instance
+
+  constructor: (atts) ->
+    super
+    @load atts if atts
+    @cid = @constructor.uid('c-')
+
+  isNew: ->
+    not @exists()
+
+  isValid: ->
+    not @validate()
+
+  validate: ->
+
+  load: (atts) ->
+    for key, value of atts
+      if typeof @[key] is 'function'
+        @[key](value)
+      else
+        @[key] = value
+    this
+
+  attributes: ->
+    result = {}
+    for key in @constructor.attributes when key of this
+      if typeof @[key] is 'function'
+        result[key] = @[key]()
+      else
+        result[key] = @[key]
+    result.id = @id if @id
+    result
+
+  eql: (rec) ->
+    !!(rec and rec.constructor is @constructor and
+        (rec.cid is @cid) or (rec.id and rec.id is @id))
+
+  save: (options = {}) ->
+    unless options.validate is false
+      error = @validate()
+      if error
+        @trigger('error', error)
+        return false
+
+    @trigger('beforeSave', options)
+    record = if @isNew() then @create(options) else @update(options)
+    @trigger('save', options)
+    record
+
+  updateAttribute: (name, value, options) ->
+    @[name] = value
+    @save(options)
+
+  updateAttributes: (atts, options) ->
+    @load(atts)
+    @save(options)
+
+  changeID: (id) ->
+    records = @constructor.records
+    records[id] = records[@id]
+    delete records[@id]
+    @id = id
+    @save()
+
+  destroy: (options = {}) ->
+    @trigger('beforeDestroy', options)
+    delete @constructor.records[@id]
+    delete @constructor.crecords[@cid]
+    @destroyed = true
+    @trigger('destroy', options)
+    @trigger('change', 'destroy', options)
+    @unbind()
+    this
+
+  dup: (newRecord) ->
+    result = new @constructor(@attributes())
+    if newRecord is false
+      result.cid = @cid
+    else
+      delete result.id
+    result
+
+  clone: ->
+    createObject(this)
+
+  reload: ->
+    return this if @isNew()
+    original = @constructor.find(@id)
+    @load(original.attributes())
+    original
+
+  toJSON: ->
+    @attributes()
+
+  toString: ->
+    "<#{@constructor.className} (#{JSON.stringify(this)})>"
+
+  fromForm: (form) ->
+    result = {}
+    for key in $(form).serializeArray()
+      result[key.name] = key.value
+    @load(result)
+
+  exists: ->
+    @id && @id of @constructor.records
+
+  # Private
+
+  update: (options) ->
+    @trigger('beforeUpdate', options)
+    records = @constructor.records
+    records[@id].load @attributes()
+    clone = records[@id].clone()
+    clone.trigger('update', options)
+    clone.trigger('change', 'update', options)
+    clone
+
+  create: (options) ->
+    @trigger('beforeCreate', options)
+    @id          = @cid unless @id
+
+    record       = @dup(false)
+    @constructor.records[@id]   = record
+    @constructor.crecords[@cid] = record
+
+    clone        = record.clone()
+    clone.trigger('create', options)
+    clone.trigger('change', 'create', options)
+    clone
+
+  bind: (events, callback) ->
+    @constructor.bind events, binder = (record) =>
+      if record && @eql(record)
+        callback.apply(this, arguments)
+    @constructor.bind 'unbind', unbinder = (record) =>
+      if record && @eql(record)
+        @constructor.unbind(events, binder)
+        @constructor.unbind('unbind', unbinder)
+    binder
+
+  one: (events, callback) ->
+    binder = @bind events, =>
+      @constructor.unbind(events, binder)
+      callback.apply(this, arguments)
+
+  trigger: (args...) ->
+    args.splice(1, 0, this)
+    @constructor.trigger(args...)
+
+  unbind: ->
+    @trigger('unbind')
+
+class Controller extends Module
+  @include Events
+  @include Log
+
+  eventSplitter: /^(\S+)\s*(.*)$/
+  tag: 'div'
+
+  constructor: (options) ->
+    @options = options
+
+    for key, value of @options
+      @[key] = value
+
+    @el  = document.createElement(@tag) unless @el
+    @el  = $(@el)
+    @$el = @el
+
+    @el.addClass(@className) if @className
+    @el.attr(@attributes) if @attributes
+
+    @events = @constructor.events unless @events
+    @elements = @constructor.elements unless @elements
+
+    @delegateEvents(@events) if @events
+    @refreshElements() if @elements
+
+    super
+
+  release: =>
+    @trigger 'release'
+    @el.remove()
+    @unbind()
+
+  $: (selector) -> $(selector, @el)
+
+  delegateEvents: (events) ->
+    for key, method of events
+
+      if typeof(method) is 'function'
+        # Always return true from event handlers
+        method = do (method) => =>
+          method.apply(this, arguments)
+          true
+      else
+        unless @[method]
+          throw new Error("#{method} doesn't exist")
+
+        method = do (method) => =>
+          @[method].apply(this, arguments)
+          true
+
+      match      = key.match(@eventSplitter)
+      eventName  = match[1]
+      selector   = match[2]
+
+      if selector is ''
+        @el.bind(eventName, method)
+      else
+        @el.delegate(selector, eventName, method)
+
+  refreshElements: ->
+    for key, value of @elements
+      @[value] = @$(key)
+
+  delay: (func, timeout) ->
+    setTimeout(@proxy(func), timeout || 0)
+
+  html: (element) ->
+    @el.html(element.el or element)
+    @refreshElements()
+    @el
+
+  append: (elements...) ->
+    elements = (e.el or e for e in elements)
+    @el.append(elements...)
+    @refreshElements()
+    @el
+
+  appendTo: (element) ->
+    @el.appendTo(element.el or element)
+    @refreshElements()
+    @el
+
+  prepend: (elements...) ->
+    elements = (e.el or e for e in elements)
+    @el.prepend(elements...)
+    @refreshElements()
+    @el
+
+  replace: (element) ->
+    [previous, @el] = [@el, $(element.el or element)]
+    previous.replaceWith(@el)
+    @delegateEvents(@events)
+    @refreshElements()
+    @el
+
+# Utilities & Shims
+
+$ = window?.jQuery or window?.Zepto or (element) -> element
+
+createObject = Object.create or (o) ->
+  Func = ->
+  Func.prototype = o
+  new Func()
+
+isArray = (value) ->
+  Object::toString.call(value) is '[object Array]'
+
+isBlank = (value) ->
+  return true unless value
+  return false for key of value
+  true
+
+makeArray = (args) ->
+  Array::slice.call(args, 0)
+
+# Globals
+
+Spine = @Spine   = {}
+module?.exports  = Spine
+
+Spine.version    = '1.0.8'
+Spine.isArray    = isArray
+Spine.isBlank    = isBlank
+Spine.$          = $
+Spine.Events     = Events
+Spine.Log        = Log
+Spine.Module     = Module
+Spine.Controller = Controller
+Spine.Model      = Model
+
+# Global events
+
+Module.extend.call(Spine, Events)
+
+# JavaScript compatability
+
+Module.create = Module.sub =
+  Controller.create = Controller.sub =
+    Model.sub = (instances, statics) ->
+      class Result extends this
+      Result.include(instances) if instances
+      Result.extend(statics) if statics
+      Result.unbind?()
+      Result
+
+Model.setup = (name, attributes = []) ->
+  class Instance extends this
+  Instance.configure(name, attributes...)
+  Instance
+
+Spine.Class = Module