event_cal 1.0

data/vendor/assets/javascripts/lib/spinelib/ajax.js.coffee

@@ -0,0 +1,223 @@
+Spine  = @Spine or require('spine')
+$      = Spine.$
+Model  = Spine.Model
+Queue  = $({})
+
+Ajax =
+  getURL: (object) ->
+    object and object.url?() or object.url
+
+  enabled: true
+
+  disable: (callback) ->
+    if @enabled
+      @enabled = false
+      try
+        do callback
+      catch e
+        throw e
+      finally
+        @enabled = true
+    else
+      do callback
+
+  queue: (request) ->
+    if request then Queue.queue(request) else Queue.queue()
+
+  clearQueue: ->
+    @queue []
+
+class Base
+  defaults:
+    contentType: 'application/json'
+    dataType: 'json'
+    processData: false
+    headers: {'X-Requested-With': 'XMLHttpRequest'}
+
+  queue: Ajax.queue
+
+  ajax: (params, defaults) ->
+    $.ajax @ajaxSettings(params, defaults)
+
+  ajaxQueue: (params, defaults) ->
+    jqXHR    = null
+    deferred = $.Deferred()
+
+    promise  = deferred.promise()
+    return promise unless Ajax.enabled
+
+    settings = @ajaxSettings(params, defaults)
+
+    request = (next) ->
+      jqXHR = $.ajax(settings)
+                .done(deferred.resolve)
+                .fail(deferred.reject)
+                .then(next, next)
+
+    promise.abort = (statusText) ->
+      return jqXHR.abort(statusText) if jqXHR
+      index = $.inArray(request, @queue())
+      @queue().splice(index, 1) if index > -1
+
+      deferred.rejectWith(
+        settings.context or settings,
+        [promise, statusText, '']
+      )
+      promise
+
+    @queue request
+    promise
+
+  ajaxSettings: (params, defaults) ->
+    $.extend({}, @defaults, defaults, params)
+
+class Collection extends Base
+  constructor: (@model) ->
+
+  find: (id, params) ->
+    record = new @model(id: id)
+    @ajaxQueue(
+      params,
+      type: 'GET',
+      url:  Ajax.getURL(record)
+    ).done(@recordsResponse)
+     .fail(@failResponse)
+
+  all: (params) ->
+    @ajaxQueue(
+      params,
+      type: 'GET',
+      url:  Ajax.getURL(@model)
+    ).done(@recordsResponse)
+     .fail(@failResponse)
+
+  fetch: (params = {}, options = {}) ->
+    if id = params.id
+      delete params.id
+      @find(id, params).done (record) =>
+        @model.refresh(record, options)
+    else
+      @all(params).done (records) =>
+        @model.refresh(records, options)
+
+  # Private
+
+  recordsResponse: (data, status, xhr) =>
+    @model.trigger('ajaxSuccess', null, status, xhr)
+
+  failResponse: (xhr, statusText, error) =>
+    @model.trigger('ajaxError', null, xhr, statusText, error)
+
+class Singleton extends Base
+  constructor: (@record) ->
+    @model = @record.constructor
+
+  reload: (params, options) ->
+    @ajaxQueue(
+      params,
+      type: 'GET'
+      url:  Ajax.getURL(@record)
+    ).done(@recordResponse(options))
+     .fail(@failResponse(options))
+
+  create: (params, options) ->
+    @ajaxQueue(
+      params,
+      type: 'POST'
+      data: JSON.stringify(@record)
+      url:  Ajax.getURL(@model)
+    ).done(@recordResponse(options))
+     .fail(@failResponse(options))
+
+  update: (params, options) ->
+    @ajaxQueue(
+      params,
+      type: 'PUT'
+      data: JSON.stringify(@record)
+      url:  Ajax.getURL(@record)
+    ).done(@recordResponse(options))
+     .fail(@failResponse(options))
+
+  destroy: (params, options) ->
+    @ajaxQueue(
+      params,
+      type: 'DELETE'
+      url:  Ajax.getURL(@record)
+    ).done(@recordResponse(options))
+     .fail(@failResponse(options))
+
+  # Private
+
+  recordResponse: (options = {}) =>
+    (data, status, xhr) =>
+      if Spine.isBlank(data)
+        data = false
+      else
+        data = @model.fromJSON(data)
+
+      Ajax.disable =>
+        if data
+          # ID change, need to do some shifting
+          if data.id and @record.id isnt data.id
+            @record.changeID(data.id)
+
+          # Update with latest data
+          @record.updateAttributes(data.attributes())
+
+      @record.trigger('ajaxSuccess', data, status, xhr)
+      options.success?.apply(@record) # Deprecated
+      options.done?.apply(@record)
+
+  failResponse: (options = {}) =>
+    (xhr, statusText, error) =>
+      @record.trigger('ajaxError', xhr, statusText, error)
+      options.error?.apply(@record) # Deprecated
+      options.fail?.apply(@record)
+
+# Ajax endpoint
+Model.host = ''
+
+Include =
+  ajax: -> new Singleton(this)
+
+  url: (args...) ->
+    url = Ajax.getURL(@constructor)
+    url += '/' unless url.charAt(url.length - 1) is '/'
+    url += encodeURIComponent(@id)
+    args.unshift(url)
+    args.join('/')
+
+Extend =
+  ajax: -> new Collection(this)
+
+  url: (args...) ->
+    args.unshift(@className.toLowerCase() + 's')
+    args.unshift(Model.host)
+    args.join('/')
+
+Model.Ajax =
+  extended: ->
+    @fetch @ajaxFetch
+    @change @ajaxChange
+
+    @extend Extend
+    @include Include
+
+  # Private
+
+  ajaxFetch: ->
+    @ajax().fetch(arguments...)
+
+  ajaxChange: (record, type, options = {}) ->
+    return if options.ajax is false
+    record.ajax()[type](options.ajax, options)
+
+Model.Ajax.Methods =
+  extended: ->
+    @extend Extend
+    @include Include
+
+# Globals
+Ajax.defaults   = Base::defaults
+Spine.Ajax      = Ajax
+module?.exports = Ajax

data/vendor/assets/javascripts/lib/spinelib/list.js.coffee

@@ -0,0 +1,43 @@
+Spine  = @Spine or require('spine')
+$      = Spine.$
+
+class Spine.List extends Spine.Controller
+  events:
+    'click .item': 'click'
+
+  selectFirst: false
+
+  constructor: ->
+    super
+    @bind 'change', @change
+
+  template: ->
+    throw 'Override template'
+
+  change: (item) =>
+    @current = item
+
+    unless @current
+      @children().removeClass('active')
+      return
+
+    @children().removeClass('active')
+    $(@children().get(@items.indexOf(@current))).addClass('active')
+
+  render: (items) ->
+    @items = items if items
+    @html @template(@items)
+    @change @current
+    if @selectFirst
+      unless @children('.active').length
+        @children(':first').click()
+
+  children: (sel) ->
+    @el.children(sel)
+
+  click: (e) ->
+    item = @items[$(e.currentTarget).index()]
+    @trigger('change', item)
+    true
+
+module?.exports = Spine.List

data/vendor/assets/javascripts/lib/spinelib/local.js.coffee

@@ -0,0 +1,16 @@
+Spine = @Spine or require('spine')
+
+Spine.Model.Local =
+  extended: ->
+    @change @saveLocal
+    @fetch @loadLocal
+
+  saveLocal: ->
+    result = JSON.stringify(@)
+    localStorage[@className] = result
+
+  loadLocal: ->
+    result = localStorage[@className]
+    @refresh(result or [], clear: true)
+
+module?.exports = Spine.Model.Local

data/vendor/assets/javascripts/lib/spinelib/manager.js.coffee

@@ -0,0 +1,83 @@
+Spine  = @Spine or require('spine')
+$      = Spine.$
+
+class Spine.Manager extends Spine.Module
+  @include Spine.Events
+
+  constructor: ->
+    @controllers = []
+    @bind 'change', @change
+    @add(arguments...)
+
+  add: (controllers...) ->
+    @addOne(cont) for cont in controllers
+
+  addOne: (controller) ->
+    controller.bind 'active', (args...) =>
+      @trigger('change', controller, args...)
+    controller.bind 'release', =>
+      @controllers.splice(@controllers.indexOf(controller), 1)
+
+    @controllers.push(controller)
+
+  deactivate: ->
+    @trigger('change', false, arguments...)
+
+  # Private
+
+  change: (current, args...) ->
+    for cont in @controllers
+      if cont is current
+        cont.activate(args...)
+      else
+        cont.deactivate(args...)
+
+Spine.Controller.include
+  active: (args...) ->
+    if typeof args[0] is 'function'
+      @bind('active', args[0])
+    else
+      args.unshift('active')
+      @trigger(args...)
+    @
+
+  isActive: ->
+    @el.hasClass('active')
+
+  activate: ->
+    @el.addClass('active')
+    @
+
+  deactivate: ->
+    @el.removeClass('active')
+    @
+
+class Spine.Stack extends Spine.Controller
+  controllers: {}
+  routes: {}
+
+  className: 'spine stack'
+
+  constructor: ->
+    super
+
+    @manager = new Spine.Manager
+
+    for key, value of @controllers
+      @[key] = new value(stack: @)
+      @add(@[key])
+
+    for key, value of @routes
+      do (key, value) =>
+        callback = value if typeof value is 'function'
+        callback or= => @[value].active(arguments...)
+        @route(key, callback)
+
+    @[@default].active() if @default
+
+  add: (controller) ->
+    @manager.add(controller)
+    @append(controller)
+
+module?.exports = Spine.Manager
+module?.exports.Stack = Spine.Stack

data/vendor/assets/javascripts/lib/spinelib/relation.js.coffee

@@ -0,0 +1,144 @@
+Spine   = @Spine or require('spine')
+isArray = Spine.isArray
+require = @require or ((value) -> eval(value))
+
+class Collection extends Spine.Module
+  constructor: (options = {}) ->
+    for key, value of options
+      @[key] = value
+
+  all: ->
+    @model.select (rec) => @associated(rec)
+
+  first: ->
+    @all()[0]
+
+  last: ->
+    values = @all()
+    values[values.length - 1]
+
+  find: (id) ->
+    records = @select (rec) =>
+      rec.id + '' is id + ''
+    throw('Unknown record') unless records[0]
+    records[0]
+
+  findAllByAttribute: (name, value) ->
+    @model.select (rec) =>
+      @associated(rec) and rec[name] is value
+
+  findByAttribute: (name, value) ->
+    @findAllByAttribute(name, value)[0]
+
+  select: (cb) ->
+    @model.select (rec) =>
+      @associated(rec) and cb(rec)
+
+  refresh: (values) ->
+    delete @model.records[record.id] for record in @all()
+    records = @model.fromJSON(values)
+
+    records = [records] unless isArray(records)
+
+    for record in records
+      record.newRecord = false
+      record[@fkey] = @record.id
+      @model.records[record.id] = record
+
+    @model.trigger('refresh', @model.cloneArray(records))
+
+  create: (record) ->
+    record[@fkey] = @record.id
+    @model.create(record)
+
+  # Private
+
+  associated: (record) ->
+    record[@fkey] is @record.id
+
+class Instance extends Spine.Module
+  constructor: (options = {}) ->
+    for key, value of options
+      @[key] = value
+
+  exists: ->
+    @record[@fkey] and @model.exists(@record[@fkey])
+
+  update: (value) ->
+    unless value instanceof @model
+      value = new @model(value)
+    value.save() if value.isNew()
+    @record[@fkey] = value and value.id
+
+class Singleton extends Spine.Module
+  constructor: (options = {}) ->
+    for key, value of options
+      @[key] = value
+
+  find: ->
+    @record.id and @model.findByAttribute(@fkey, @record.id)
+
+  update: (value) ->
+    unless value instanceof @model
+      value = @model.fromJSON(value)
+
+    value[@fkey] = @record.id
+    value.save()
+
+singularize = (str) ->
+  str.replace(/s$/, '')
+
+underscore = (str) ->
+  str.replace(/::/g, '/')
+     .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+     .replace(/([a-z\d])([A-Z])/g, '$1_$2')
+     .replace(/-/g, '_')
+     .toLowerCase()
+
+Spine.Model.extend
+  hasMany: (name, model, fkey) ->
+    fkey ?= "#{underscore(this.className)}_id"
+
+    association = (record) ->
+      model = require(model) if typeof model is 'string'
+
+      new Collection(
+        name: name, model: model,
+        record: record, fkey: fkey
+      )
+
+    @::[name] = (value) ->
+      association(@).refresh(value) if value?
+      association(@)
+
+  belongsTo: (name, model, fkey) ->
+    fkey ?= "#{singularize(name)}_id"
+
+    association = (record) ->
+      model = require(model) if typeof model is 'string'
+
+      new Instance(
+        name: name, model: model,
+        record: record, fkey: fkey
+      )
+
+    @::[name] = (value) ->
+      association(@).update(value) if value?
+      association(@).exists()
+
+    @attributes.push(fkey)
+
+  hasOne: (name, model, fkey) ->
+    fkey ?= "#{underscore(@className)}_id"
+
+    association = (record) ->
+      model = require(model) if typeof model is 'string'
+
+      new Singleton(
+        name: name, model: model,
+        record: record, fkey: fkey
+      )
+
+    @::[name] = (value) ->
+      association(@).update(value) if value?
+      association(@).find()

data/vendor/assets/javascripts/lib/spinelib/route.js.coffee

@@ -0,0 +1,151 @@
+Spine = @Spine or require('spine')
+$     = Spine.$
+
+hashStrip    = /^#*/
+namedParam   = /:([\w\d]+)/g
+splatParam   = /\*([\w\d]+)/g
+escapeRegExp = /[-[\]{}()+?.,\\^$|#\s]/g
+
+class Spine.Route extends Spine.Module
+  @extend Spine.Events
+
+  @historySupport: window.history?.pushState?
+
+  @routes: []
+
+  @options:
+    trigger: true
+    history: false
+    shim: false
+
+  @add: (path, callback) ->
+    if (typeof path is 'object' and path not instanceof RegExp)
+      @add(key, value) for key, value of path
+    else
+      @routes.push(new @(path, callback))
+
+  @setup: (options = {}) ->
+    @options = $.extend({}, @options, options)
+
+    if (@options.history)
+      @history = @historySupport && @options.history
+
+    return if @options.shim
+
+    if @history
+      $(window).bind('popstate', @change)
+    else
+      $(window).bind('hashchange', @change)
+    @change()
+
+  @unbind: ->
+    return if @options.shim
+
+    if @history
+      $(window).unbind('popstate', @change)
+    else
+      $(window).unbind('hashchange', @change)
+
+  @navigate: (args...) ->
+    options = {}
+
+    lastArg = args[args.length - 1]
+    if typeof lastArg is 'object'
+      options = args.pop()
+    else if typeof lastArg is 'boolean'
+      options.trigger = args.pop()
+
+    options = $.extend({}, @options, options)
+
+    path = args.join('/')
+    return if @path is path
+    @path = path
+
+    @trigger('navigate', @path)
+
+    @matchRoute(@path, options) if options.trigger
+
+    return if options.shim
+
+    if @history
+      history.pushState(
+        {},
+        document.title,
+        @path
+      )
+    else
+      window.location.hash = @path
+
+  # Private
+
+  @getPath: ->
+    path = window.location.pathname
+    if path.substr(0,1) isnt '/'
+      path = '/' + path
+    path
+
+  @getHash: -> window.location.hash
+
+  @getFragment: -> @getHash().replace(hashStrip, '')
+
+  @getHost: ->
+    (document.location + '').replace(@getPath() + @getHash(), '')
+
+  @change: ->
+    path = if @history then @getPath() else @getFragment()
+    return if path is @path
+    @path = path
+    @matchRoute(@path)
+
+  @matchRoute: (path, options) ->
+    for route in @routes
+      if route.match(path, options)
+        @trigger('change', route, path)
+        return route
+
+  constructor: (@path, @callback) ->
+    @names = []
+
+    if typeof path is 'string'
+      namedParam.lastIndex = 0
+      while (match = namedParam.exec(path)) != null
+        @names.push(match[1])
+
+      splatParam.lastIndex = 0
+      while (match = splatParam.exec(path)) != null
+        @names.push(match[1])
+
+      path = path.replace(escapeRegExp, '\\$&')
+                 .replace(namedParam, '([^\/]*)')
+                 .replace(splatParam, '(.*?)')
+
+      @route = new RegExp('^' + path + '$')
+    else
+      @route = path
+
+  match: (path, options = {}) ->
+    match = @route.exec(path)
+    return false unless match
+    options.match = match
+    params = match.slice(1)
+
+    if @names.length
+      for param, i in params
+        options[@names[i]] = param
+
+    @callback.call(null, options) isnt false
+
+# Coffee-script bug
+Spine.Route.change = Spine.Route.proxy(Spine.Route.change)
+
+Spine.Controller.include
+  route: (path, callback) ->
+    Spine.Route.add(path, @proxy(callback))
+
+  routes: (routes) ->
+    @route(key, value) for key, value of routes
+
+  navigate: ->
+    Spine.Route.navigate.apply(Spine.Route, arguments)
+
+module?.exports = Spine.Route

data/vendor/assets/javascripts/models/calendarDate.js.coffee

@@ -0,0 +1,7 @@
+class CalendarDate extends Spine.Model
+  @configure 'CalendarDate', 'element', 'date', 'active'
+
+  @deactivateAllDates: () ->
+    CalendarDate.each((date) -> date.updateAttributes(active: false))
+
+window.CalendarDate = CalendarDate

data/vendor/assets/javascripts/models/calendarEvent.js.coffee

@@ -0,0 +1,11 @@
+class CalendarEvent extends Spine.Model
+  @configure 'CalendarEvent', 'held_on', 'active', 'element'
+
+  @activateAllEventsOn: (date) ->
+    for event in CalendarEvent.findAllByAttribute('held_on', date)
+      event.updateAttributes(active: true)
+
+  @deactivateAllEvents: () ->
+    CalendarEvent.each((event) -> event.updateAttributes(active: false))
+
+window.CalendarEvent = CalendarEvent