scales-monitor 0.0.1.beta.1

data/lib/scales-monitor/app/app/assets/javascripts/lib/spine/ajax.coffee

@@ -0,0 +1,208 @@
+Spine  = @Spine or require('spine')
+$      = Spine.$
+Model  = Spine.Model
+
+Ajax =
+  getURL: (object) ->
+    object and object.url?() or object.url
+
+  enabled:  true
+  pending:  false
+  requests: []
+
+  disable: (callback) ->
+    if @enabled
+      @enabled = false
+      try
+        do callback
+      catch e
+        throw e
+      finally
+        @enabled = true
+    else
+      do callback
+
+  requestNext: ->
+    next = @requests.shift()
+    if next
+      @request(next)
+    else
+      @pending = false
+
+  request: (callback) ->
+    (do callback).complete(=> do @requestNext)
+
+  queue: (callback) ->
+    return unless @enabled
+    if @pending
+      @requests.push(callback)
+    else
+      @pending = true
+      @request(callback)
+    callback
+
+class Base
+  defaults:
+    contentType: 'application/json'
+    dataType: 'json'
+    processData: false
+    headers: {'X-Requested-With': 'XMLHttpRequest'}
+
+  ajax: (params, defaults) ->
+    $.ajax($.extend({}, @defaults, defaults, params))
+
+  queue: (callback) ->
+    Ajax.queue(callback)
+
+class Collection extends Base
+  constructor: (@model) ->
+
+  find: (id, params) ->
+    record = new @model(id: id)
+    @ajax(
+      params,
+      type: 'GET',
+      url:  Ajax.getURL(record)
+    ).success(@recordsResponse)
+     .error(@errorResponse)
+
+  all: (params) ->
+    @ajax(
+      params,
+      type: 'GET',
+      url:  Ajax.getURL(@model)
+    ).success(@recordsResponse)
+     .error(@errorResponse)
+
+  fetch: (params = {}, options = {}) ->
+    if id = params.id
+      delete params.id
+      @find(id, params).success (record) =>
+        @model.refresh(record, options)
+    else
+      @all(params).success (records) =>
+        @model.refresh(records, options)
+
+  # Private
+
+  recordsResponse: (data, status, xhr) =>
+    @model.trigger('ajaxSuccess', null, status, xhr)
+
+  errorResponse: (xhr, statusText, error) =>
+    @model.trigger('ajaxError', null, xhr, statusText, error)
+
+class Singleton extends Base
+  constructor: (@record) ->
+    @model = @record.constructor
+
+  reload: (params, options) ->
+    @queue =>
+      @ajax(
+        params,
+        type: 'GET'
+        url:  Ajax.getURL(@record)
+      ).success(@recordResponse(options))
+       .error(@errorResponse(options))
+
+  create: (params, options) ->
+    @queue =>
+      @ajax(
+        params,
+        type: 'POST'
+        data: JSON.stringify(@record)
+        url:  Ajax.getURL(@model)
+      ).success(@recordResponse(options))
+       .error(@errorResponse(options))
+
+  update: (params, options) ->
+    @queue =>
+      @ajax(
+        params,
+        type: 'PUT'
+        data: JSON.stringify(@record)
+        url:  Ajax.getURL(@record)
+      ).success(@recordResponse(options))
+       .error(@errorResponse(options))
+
+  destroy: (params, options) ->
+    @queue =>
+      @ajax(
+        params,
+        type: 'DELETE'
+        url:  Ajax.getURL(@record)
+      ).success(@recordResponse(options))
+       .error(@errorResponse(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)
+
+  errorResponse: (options = {}) =>
+    (xhr, statusText, error) =>
+      @record.trigger('ajaxError', xhr, statusText, error)
+      options.error?.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/lib/scales-monitor/app/app/assets/javascripts/lib/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/lib/scales-monitor/app/app/assets/javascripts/lib/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/lib/scales-monitor/app/app/assets/javascripts/lib/spine/manager.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/lib/scales-monitor/app/app/assets/javascripts/lib/spine/relation.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()