spine-rails 0.1.0 → 0.1.1

data/vendor/assets/javascripts/spine/ajax.coffee

@@ -0,0 +1,237 @@
+Spine  = @Spine or require('spine')
+$      = Spine.$
+Model  = Spine.Model
+Queue  = $({})
+
+Ajax =
+  getURL: (object) ->
+    object and object.url?() or object.url
+
+  getScope: (object) ->
+    scope = object and object.scope?() or object.scope
+    if scope? and scope.charAt(0) is '/'
+      scope = scope.substring(1)
+    scope
+
+  generateURL: (object, args...) ->
+    if object.className
+      collection = object.className.toLowerCase() + 's'
+      scope = Ajax.getScope(object)
+    else
+      if typeof object.constructor.url is 'string'
+        collection = object.constructor.url
+        collection = collection.substring(1) if collection.charAt(0) is '/'
+      else
+        collection = object.constructor.className.toLowerCase() + 's'
+      scope = Ajax.getScope(object) or Ajax.getScope(object.constructor)
+    args.unshift(collection)
+    if scope?
+      args.unshift(scope)
+    args.unshift(Model.host)
+    args.join('/')
+
+  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:
+    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'
+      contentType: 'application/json'
+      data: JSON.stringify(@record)
+      url:  Ajax.getURL(@model)
+    ).done(@recordResponse(options))
+     .fail(@failResponse(options))
+
+  update: (params, options) ->
+    @ajaxQueue(
+      params,
+      type: 'PUT'
+      contentType: 'application/json'
+      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) or @record.destroyed
+        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...) ->
+    args.unshift(encodeURIComponent(@id))
+    Ajax.generateURL(@, args...)
+
+Extend =
+  ajax: -> new Collection(this)
+
+  url: (args...) ->
+    Ajax.generateURL(@, args...)
+
+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/spine/list.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/spine/local.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/spine/manager.coffee

@@ -0,0 +1,84 @@
+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
+      throw Error "'@#{ key }' already assigned - choose a different name" if @[key]?
+      @[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/spine/relation.coffee

@@ -0,0 +1,136 @@
+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]
+
+  count: ->
+    @all().length
+
+  find: (id) ->
+    records = @select (rec) =>
+      "#{rec.id}" is "#{id}"
+    throw new Error("\"#{@model.className}\" model could not find a record for the ID \"#{id}\"") 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) ->
+    return this unless values?
+    for record in @all()
+      delete @model.irecords[record.id]
+      for match, i in @model.records when match.id is record.id
+        @model.records.splice(i, 1)
+        break
+    values = [values] unless isArray(values)
+    for record in values
+      record.newRecord = false
+      record[@fkey] = @record.id
+    @model.refresh values
+    this
+
+  create: (record, options) ->
+    record[@fkey] = @record.id
+    @model.create(record, options)
+
+  add: (record, options) ->
+    record.updateAttribute @fkey, @record.id, options
+
+  remove: (record, options) ->
+    record.updateAttribute @fkey, null, options
+
+  # Private
+
+  associated: (record) ->
+    record[@fkey] is @record.id
+
+class Instance extends Spine.Module
+  constructor: (options = {}) ->
+    for key, value of options
+      @[key] = value
+
+  exists: ->
+    return if @record[@fkey] then @model.exists(@record[@fkey]) else false
+
+  update: (value) ->
+    return this unless value?
+    unless value instanceof @model
+      value = new @model(value)
+    value.save() if value.isNew()
+    @record[@fkey] = value and value.id
+    this
+
+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) ->
+    return this unless value?
+    unless value instanceof @model
+      value = @model.fromJSON(value)
+
+    value[@fkey] = @record.id
+    value.save()
+    this
+
+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()
+
+association = (name, model, record, fkey, Ctor) ->
+  model = require(model) if typeof model is 'string'
+  new Ctor(name: name, model: model, record: record, fkey: fkey)
+
+Spine.Model.extend
+  hasMany: (name, model, fkey) ->
+    fkey ?= "#{underscore(this.className)}_id"
+    @::[name] = (value) ->
+      association(name, model, @, fkey, Collection).refresh(value)
+
+  belongsTo: (name, model, fkey) ->
+    fkey ?= "#{underscore(singularize(name))}_id"
+    @::[name] = (value) ->
+      association(name, model, @, fkey, Instance).update(value).exists()
+
+    @attributes.push(fkey)
+
+  hasOne: (name, model, fkey) ->
+    fkey ?= "#{underscore(@className)}_id"
+    @::[name] = (value) ->
+      association(name, model, @, fkey, Singleton).update(value).find()
+
+Spine.Collection = Collection
+Spine.Singleton = Singleton
+Spine.Instance = Instance