spine-rails 0.1.0 → 0.1.1

data/README.md

@@ -14,10 +14,19 @@ This gem does two things:
 
 ### Installation
 
-In your Gemfile, add this line:
+In your Gemfile, add the following lines:
 
+    gem "json2-rails"
     gem "spine-rails"
 
+Make sure that your Gemfile also includes
+
+    gem "jquery-rails"
+    
+Or if your using Zepto
+
+    gem "zepto-rails"
+
 Then run the following commands:
 
     bundle install
@@ -71,7 +80,7 @@ The generator will create views in `hamljs`, `eco` or `ejs` format, depending on
 
 ## Example Usage
 
-Created a new Rails 3.1 application called `blog`.
+Created a new Rails application called `blog`.
 
     rails new blog
 
@@ -120,4 +129,4 @@ Also if you want to have some useful helpers to bridge the gap between Spine and
 
 ## Attributions
 
-This plugin was made by [Alex MacCaw](http://alexmaccaw.co.uk) with major contributions from [Dmytrii Nagirniak](https://github.com/dnagir). It's under the same license as [Spine](http://spinejs.com) (MIT).
+This plugin was made by [Alex MacCaw](http://alexmaccaw.co.uk) with major contributions from [Dmytrii Nagirniak](https://github.com/dnagir) [Zohar Arad] (https:://github.com/zohararad) and [Ben Haines] (http://github.com/benhainez). It's under the same license as [Spine](http://spinejs.com) (MIT).

data/build/update.sh

@@ -0,0 +1,9 @@
+TAG=v1.1.0
+FILES=( ajax list local manager relation route )
+curl -s -o vendor/assets/javascripts/spine.coffee https://raw.github.com/spine/spine/$TAG/src/spine.coffee
+
+for i in "${FILES[@]}"
+do
+   :
+   curl -s -o vendor/assets/javascripts/spine/$i.coffee https://raw.github.com/spine/spine/$TAG/src/$i.coffee
+done

data/lib/generators/spine/model/model_generator.rb

@@ -7,7 +7,7 @@ module Spine
       source_root File.expand_path("../templates", __FILE__)
       desc "Generate a Spine model with configured fields"
 
-      argument :fields, :desc => 'List of model attributes', :type => :array, :banner => 'field1 field2'
+      argument :fields, desc: 'List of model attributes', type: :array, banner: 'field1 field2'
 
       def create_model
         template "model.coffee.erb", "app/assets/javascripts/#{app_name}/models/#{file_name}.js.coffee"

data/lib/generators/spine/new/new_generator.rb

@@ -4,40 +4,40 @@ module Spine
   module Generators
     class NewGenerator < ::Rails::Generators::Base
       source_root File.expand_path("../templates", __FILE__)
-  
+
       desc "This generator installs Spine #{Spine::Rails::SPINE_VERSION} as part of assets pipeline"
-      
-      class_option :app, :type => :string, :default => "app", :desc => "app name"
-      
+
+      class_option :app, type: :string, default: "app", desc: "app name"
+
       def app_name
         options[:app]
       end
-      
+
       def app_class
         app_name.camelize
       end
-          
+
       def create_dir_layout
         %W{models views controllers lib}.each do |dir|
-          empty_directory "app/assets/javascripts/#{app_name}/#{dir}" 
-          create_file "app/assets/javascripts/#{app_name}/#{dir}/.gitkeep"
+          empty_directory "app/assets/javascripts/#{app_name}/#{dir}"
+          create_file "app/assets/javascripts/#{app_name}/#{dir}/.keep"
         end
       end
-    
+
       def create_app_file
         template "index.coffee.erb", "app/assets/javascripts/#{app_name}/index.js.coffee"
       end
-      
+
       def create_lib_file
-        template "view.coffee.erb", "app/assets/javascripts/#{app_name}/lib/view.js.coffee"        
+        template "view.coffee.erb", "app/assets/javascripts/#{app_name}/lib/view.js.coffee"
       end
-     
+
       def add_spine_app_to_application
         source  = "app/assets/javascripts/application.js"
         content = File.read(source)
-        
+
         if content.include?("//= require_tree .")
-          inject_into_file source, :before => "//= require_tree ." do
+          inject_into_file source, before: "//= require_tree ." do
             "//= require #{app_name}\n"
           end
         else

data/lib/generators/spine/scaffold/scaffold_generator.rb

@@ -7,11 +7,11 @@ module Spine
       source_root File.expand_path("../templates", __FILE__)
       desc "Generate a Spine scaffold with configured fields"
 
-      argument :fields, :desc => "List of model attributes", :type => :array, :banner => "field1 field2"
-      
+      argument :fields, desc: "List of model attributes", type: :array, banner: "field1 field2"
+
       def create_scaffold
         raise("The 'eco' gem is required; add it to the Gemfile") unless defined?(::Eco)
-        
+
         generate "spine:model #{model_name} #{fields.join(" ")} --app #{app_name}"
         template "controller.coffee.erb", "app/assets/javascripts/#{app_name}/controllers/#{controller_name}.js.coffee"
         template "edit.jst.erb",  "app/assets/javascripts/#{app_name}/views/#{controller_name}/edit.jst.eco"
@@ -19,9 +19,9 @@ module Spine
         template "new.jst.erb",   "app/assets/javascripts/#{app_name}/views/#{controller_name}/new.jst.eco"
         template "show.jst.erb",  "app/assets/javascripts/#{app_name}/views/#{controller_name}/show.jst.eco"
       end
-      
+
       protected
-        
+
         def model_name
           file_name.singularize
         end

data/lib/generators/spine/scaffold/templates/controller.coffee.erb

@@ -1,4 +1,4 @@
-$ = jQuery.sub()
+$ = Spine.$
 <%= model_class %> = <%= app_class %>.<%= model_class %>
 
 $.fn.item = ->

data/lib/spine/generators.rb

@@ -1,18 +1,18 @@
 module Spine
   module Generators
     class Base < ::Rails::Generators::NamedBase
-      class_option :app, :type => :string, :default => "app", :desc => "app name"
-      
+      class_option :app, type: :string, default: "app", desc: "app name"
+
       protected
-      
+
         def class_name
           (class_path + [file_name]).map!{ |m| m.camelize }.join('')
         end
-      
+
         def app_name
           options[:app]
         end
-      
+
         def app_class
           app_name.camelize
         end

data/lib/spine/rails/version.rb

@@ -1,6 +1,6 @@
 module Spine
   module Rails
-    VERSION = "0.1.0"
-    SPINE_VERSION = "1.0.6"
+    VERSION = "0.1.1"
+    SPINE_VERSION = "1.1.0"
   end
 end

data/spine-rails.gemspec

@@ -15,8 +15,9 @@ Gem::Specification.new do |s|
   s.rubyforge_project         = "spine-rails"
 
   s.add_dependency             "rails", ">= 3.1.0"
+  s.add_dependency             "json2-rails", ">= 0.0.2"
   s.add_development_dependency "bundler"
-  
+
   s.files        = `git ls-files`.split("\n")
   s.executables  = `git ls-files`.split("\n").select{|f| f =~ /^bin/}
   s.require_path = 'lib'

data/vendor/assets/javascripts/spine.coffee

@@ -0,0 +1,640 @@
+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, handler = ->
+      @unbind(ev, handler)
+      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
+
+  listenTo: (obj, ev, callback) ->
+    obj.bind(ev, callback)
+    @listeningTo or= []
+    @listeningTo.push obj
+    this
+
+  listenToOnce: (obj, ev, callback) ->
+    listeningToOnce = @listeningToOnce or = []
+    listeningToOnce.push obj
+    obj.one ev, ->
+      idx = listeningToOnce.indexOf(obj)
+      listeningToOnce.splice(idx, 1) unless idx is -1
+      callback.apply(this, arguments)
+    this
+
+  stopListening: (obj, ev, callback) ->
+    if arguments.length is 0
+      retain = []
+      for listeningTo in [@listeningTo, @listeningToOnce]
+        continue unless listeningTo
+        for obj in listeningTo when not (obj in retain)
+          obj.unbind()
+          retain.push(obj)
+      @listeningTo = undefined
+      @listeningToOnce = undefined
+
+    else if obj
+      obj.unbind(ev, callback) if ev
+      obj.unbind() unless ev
+      for listeningTo in [@listeningTo, @listeningToOnce]
+        continue unless listeningTo
+        idx = listeningTo.indexOf(obj)
+        listeningTo.splice(idx, 1) unless idx is -1
+
+  unbind: (ev, callback) ->
+    if arguments.length is 0
+      @_callbacks = {}
+      return this
+    return this unless ev
+    evs = ev.split(' ')
+    for name in evs
+      list = @_callbacks?[name]
+      continue unless list
+      unless callback
+        delete @_callbacks[name]
+        continue
+      for cb, i in list when (cb is callback)
+        list = list.slice()
+        list.splice(i, 1)
+        @_callbacks[name] = list
+        break
+    this
+
+Events.on = Events.bind
+Events.off = Events.unbind
+
+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: []
+  @irecords: {}
+  @crecords: {}
+  @attributes: []
+
+  @configure: (name, attributes...) ->
+    @className = name
+    @deleteAll()
+    @attributes = attributes if attributes.length
+    @attributes and= makeArray(@attributes)
+    @attributes or=  []
+    @unbind()
+    this
+
+  @toString: -> "#{@className}(#{@attributes.join(", ")})"
+
+  @find: (id) ->
+    record = @exists(id)
+    throw new Error("\"#{@className}\" model could not find a record for the ID \"#{id}\"") unless record
+    return record
+
+  @exists: (id) ->
+    (@records[id] ? @irecords[id])?.clone()
+
+  @refresh: (values, options = {}) ->
+    if options.clear
+      @deleteAll()
+
+    records = @fromJSON(values)
+    records = [records] unless isArray(records)
+
+    for record in records
+    	if record.id and @irecords[record.id]
+    		@records[@records.indexOf(@irecords[record.id])] = record
+    	else
+	      record.id or= record.cid
+	      @records.push(record)
+      @irecords[record.id]  = record
+      @crecords[record.cid] = record
+
+    @sort()
+
+    result = @cloneArray(records)
+    @trigger('refresh', @cloneArray(records))
+    result
+
+  @select: (callback) ->
+    (record.clone() for record in @records when callback(record))
+
+  @findByAttribute: (name, value) ->
+    for record in @records
+      if record[name] is value
+        return record.clone()
+    null
+
+  @findAllByAttribute: (name, value) ->
+    @select (item) ->
+      item[name] is value
+
+  @each: (callback) ->
+    callback(record.clone()) for record in @records
+
+  @all: ->
+    @cloneArray(@records)
+
+  @first: ->
+    @records[0]?.clone()
+
+  @last: ->
+    @records[@records.length - 1]?.clone()
+
+  @count: ->
+    @records.length
+
+  @deleteAll: ->
+    @records  = []
+    @irecords = {}
+    @crecords = {}
+
+  @destroyAll: (options) ->
+    record.destroy(options) for record in @records
+
+  @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', arguments...)
+
+  @fetch: (callbackOrParams) ->
+    if typeof callbackOrParams is 'function'
+      @bind('fetch', callbackOrParams)
+    else
+      @trigger('fetch', arguments...)
+
+  @toJSON: ->
+    @records
+
+  @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...)
+
+  @sort: ->
+    if @comparator
+      @records.sort @comparator
+    @records
+
+  # Private
+
+  @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) ->
+    if atts.id then @id = atts.id
+    for key, value of atts
+      if atts.hasOwnProperty(key) and 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)
+    @stripCloneAttrs()
+    @trigger('save', options)
+    record
+
+  stripCloneAttrs: ->
+    return if @hasOwnProperty 'cid' # Make sure it's not the raw object
+    for own key, value of @
+      delete @[key] if @constructor.attributes.indexOf(key) > -1
+    this
+
+  updateAttribute: (name, value, options) ->
+    atts = {}
+    atts[name] = value
+    @updateAttributes(atts, options)
+
+  updateAttributes: (atts, options) ->
+    @load(atts)
+    @save(options)
+
+  changeID: (id) ->
+    records = @constructor.irecords
+    records[id] = records[@id]
+    delete records[@id]
+    @id = id
+    @save()
+
+  destroy: (options = {}) ->
+    @trigger('beforeDestroy', options)
+
+    # Remove record from model
+    records = @constructor.records.slice(0)
+    for record, i in records when @eql(record)
+      records.splice(i, 1)
+      break
+    @constructor.records = records
+
+    # Remove the ID and CID
+    delete @constructor.irecords[@id]
+    delete @constructor.crecords[@cid]
+
+    @destroyed = true
+    @trigger('destroy', options)
+    @trigger('change', 'destroy', options)
+    if @listeningTo
+      @stopListening()
+    @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: ->
+    @constructor.exists(@id)
+
+  # Private
+
+  update: (options) ->
+    @trigger('beforeUpdate', options)
+
+    records = @constructor.irecords
+    records[@id].load @attributes()
+
+    @constructor.sort()
+
+    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.push(record)
+    @constructor.irecords[@id]  = record
+    @constructor.crecords[@cid] = record
+
+    @constructor.sort()
+
+    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)
+    # create a wrapper function to be called with 'unbind' for each event
+    for singleEvent in events.split(' ')
+      do (singleEvent) =>
+        @constructor.bind "unbind", unbinder = (record, event, cb) =>
+          if record && @eql(record)
+            return if event and event isnt singleEvent
+            return if cb and cb isnt callback
+            @constructor.unbind(singleEvent, binder)
+            @constructor.unbind("unbind", unbinder)
+    this
+
+  one: (events, callback) ->
+    @bind events, handler = =>
+      @unbind(events, handler)
+      callback.apply(this, arguments)
+
+  trigger: (args...) ->
+    args.splice(1, 0, this)
+    @constructor.trigger(args...)
+
+  listenTo: (obj, events, callback) ->
+    obj.bind events, callback
+    @listeningTo or= []
+    @listeningTo.push(obj)
+
+  listenToOnce: (obj, events, callback) ->
+    listeningToOnce = @listeningToOnce or= []
+    listeningToOnce.push obj
+    obj.bind events, handler = =>
+      idx = listeningToOnce.indexOf(obj)
+      listeningToOnce.splice(idx, 1) unless idx is -1
+      obj.unbind(events, handler)
+      callback.apply(obj, arguments)
+
+  stopListening: (obj, events, callback) ->
+    if arguments.length is 0
+      retain = []
+      for listeningTo in [@listeningTo, @listeningToOnce]
+        continue unless listeningTo
+        for obj in @listeningTo when not (obj in retain)
+          obj.unbind()
+          retain.push(obj)
+      @listeningTo = undefined
+      @listeningToOnce = undefined
+      return
+
+    if obj
+      obj.unbind() unless events
+      obj.unbind(events, callback) if events
+      for listeningTo in [@listeningTo, @listeningToOnce]
+        continue unless listeningTo
+        idx = listeningTo.indexOf(obj)
+        listeningTo.splice(idx, 1) unless idx is -1
+
+  unbind: (events, callback) ->
+    if arguments.length is 0
+      @trigger('unbind')
+    else if events
+      for event in events.split(' ')
+        @trigger('unbind', event, callback)
+
+Model::on = Model::bind
+Model::off = Model::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
+
+    context = @
+    while parent_prototype = context.constructor.__super__
+      @events = $.extend({}, parent_prototype.events, @events) if parent_prototype.events
+      @elements = $.extend({}, parent_prototype.elements, @elements) if parent_prototype.elements
+      context = parent_prototype
+
+    @delegateEvents(@events) if @events
+    @refreshElements() if @elements
+
+    super
+
+  release: =>
+    @trigger 'release', this
+    @el.remove()
+    @unbind()
+    @stopListening()
+
+  $: (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.1.0'
+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