modularity-rails 0.15.0 → 0.16.0

data/demo/public/robots.txt

@@ -1,5 +0,0 @@
-# See http://www.robotstxt.org/wc/norobots.html for documentation on how to use the robots.txt file
-#
-# To ban all spiders from the entire site uncomment the next two lines:
-# User-Agent: *
-# Disallow: /

data/demo/script/rails

@@ -1,6 +0,0 @@
-#!/usr/bin/env ruby
-# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
-
-APP_PATH = File.expand_path('../../config/application',  __FILE__)
-require File.expand_path('../../config/boot',  __FILE__)
-require 'rails/commands'

data/demo/spec/javascripts/data/ajax_loader_spec.coffee

@@ -1,132 +0,0 @@
-#= require spec_helper
-#= require modularity/data/ajax_loader
-
-
-describe 'ajax_loader', ->
-  
-  ajax_loader = spy = spy_get = spy_fire = null
-  beforeEach ->
-    spy = sinon.spy()
-    spy_get = sinon.spy jQuery, 'get'
-    spy_fire = sinon.spy modularity, 'fire_global_event'
-
-  afterEach ->
-    spy_get.restore()
-    spy_fire.restore()
-
-  describe 'constructor', ->
-
-    it "stores the 'cache' settings", ->
-      loader = new modularity.AjaxLoader {caching: yes}
-      expect(loader.caching).to.be.true
-
-    it 'defaults to no caching', ->
-      loader = new modularity.AjaxLoader {}
-      expect(loader.caching).to.be.false
-
-
-  describe 'get', ->
-    url = "/users/4"
-
-    beforeEach ->
-      ajax_loader = new modularity.AjaxLoader {caching: yes}
-
-    describe 'first time request', ->
-
-      beforeEach ->
-        ajax_loader.get url, spy
-
-      it 'makes an ajax request', ->
-        expect(jQuery.get).to.have.been.calledOnce
-
-      it 'saves the callback for later', ->
-        expect(ajax_loader.cb_cache.get(url)).to.have.length 1
-        expect(ajax_loader.cb_cache.get(url)[0]).to.equal spy
-
-      it 'returns without calling the callback', ->
-        expect(spy).to.not.have.been.called
-
-
-    describe 'the request is already in progress', ->
-
-      existing_cb = sinon.spy()
-      new_cb = sinon.spy()
-      beforeEach ->
-        ajax_loader.cb_cache.add url, [existing_cb]
-        ajax_loader.get url, new_cb
-
-      it 'adds the callback to the callback cache', ->
-        expect(ajax_loader.cb_cache.get(url)).to.have.length 2
-        expect(ajax_loader.cb_cache.get(url)[0]).to.equal existing_cb
-        expect(ajax_loader.cb_cache.get(url)[1]).to.equal new_cb
-
-      it 'returns without calling the callback', ->
-        expect(new_cb).to.not.have.been.called
-
-      it 'does not make another ajax request', ->
-        expect(jQuery.get).to.not.have.been.called
-
-      it "does not fire the 'loading' event", ->
-        expect(modularity.fire_global_event).to.not.have.been.called
-
-
-    describe 'ajax request returns successfully', ->
-
-      old_jquery_get = null
-      beforeEach ->
-        jquery_callback = null
-        old_jquery_get = jQuery.get
-        jQuery.get = (url, callback) -> callback 'result'
-
-      afterEach ->
-        jQuery.get = old_jquery_get
-
-      describe 'with caching enabled', ->
-        beforeEach ->
-          ajax_loader.caching = true
-          ajax_loader.get url, spy
-
-        it 'calls the given callbacks with the server data', ->
-          expect(spy.calledWith('result')).to.be.true
-
-        it 'removes the callbacks from the callback cache', ->
-          expect(ajax_loader.cb_cache.get(url)).to.be.undefined
-
-        it 'stores the data in the data cache', ->
-          expect(ajax_loader.data_cache.get(url)).to.equal 'result'
-
-        it "fires the 'loading' event", ->
-          expect(modularity.fire_global_event.calledWith('AJAX_LOADED')).to.be.true
-
-
-      describe 'with caching disabled', ->
-        beforeEach ->
-          ajax_loader.caching = false
-          ajax_loader.get url, spy
-
-        it 'calls the given callbacks with the server data', ->
-          expect(spy.calledWith('result')).to.be.true
-
-        it 'removes the callbacks from the callback cache', ->
-          expect(ajax_loader.cb_cache.get(url)).to.be.undefined
-
-        it 'does not store the data in the data cache', ->
-          expect(ajax_loader.data_cache.get(url)).to.be.undefined
-
-        it "fires the 'loading' event", ->
-          expect(modularity.fire_global_event.calledWith('AJAX_LOADED')).to.be.true
-
-
-    describe 'the data has already been loaded', ->
-
-      it 'calls the callback with the cached data', ->
-        ajax_loader.data_cache.add url, "my data"
-
-        ajax_loader.get(url, spy)
-
-        expect(spy).to.have.been.called
-        expect(spy.calledWith('my data')).to.be.true
-
-      it "does not fire the 'loading' event", ->
-        expect(modularity.fire_global_event).to.not.have.been.called
-

data/demo/spec/javascripts/data/cache_spec.coffee

@@ -1,103 +0,0 @@
-#= require spec_helper
-#= require modularity/data/cache
-
-
-describe 'Cache', ->
-  
-  cache = null
-  beforeEach ->
-    cache = new modularity.Cache()
-
-
-  describe 'constructor', ->
-
-    it 'initializes with an empty cache', ->
-      cache.cache.should.eql({})
-
-
-  describe 'add', ->
-
-    it 'stores the given data in the cache', ->
-      cache.add 'foo', 'bar'
-      cache.cache.should.eql({'foo': 'bar'})
-
-    it 'overwrites existing entries', ->
-      cache.cache = {'foo', 'bar'}
-      cache.add 'foo', 'new'
-      (cache.cache['foo']).should.be.equal('new')
-
-
-  describe 'remove', ->
-
-    it 'removes the entry with the given key from the chache', ->
-      cache.add 'foo', 'bar'
-      cache.remove 'foo'
-      expect(cache.get('foo')).to.be.undefined
-      cache.length().should.equal 0
-
-    it 'only removes the given data and leaves the rest of the cache alone', ->
-      cache.add 1, 'one'
-      cache.add 2, 'two'
-      cache.remove 1
-      expect(cache.get(1)).to.be.undefined
-      expect(cache.get(2)).to.equal 'two'
-      cache.length().should.equal 1
-
-
-  describe 'get', ->
-
-    it "returns undefined if the entry doesn't exist", ->
-      expect(cache.get('zonk')).to.be.undefined
-
-    it "returns the entry if it exists", ->
-      cache.add 'foo', 'bar'
-      cache.get('foo').should.equal('bar')
-
-
-  describe 'getMany', ->
-
-    result = null
-    beforeEach ->
-      cache.add('one', 1)
-      cache.add('two', 2)
-      result = cache.getMany ['one', 'three']
-
-    it "returns the values that exist in the 'found' structure", ->
-      result.found.should.eql({'one': 1})
-
-    it "returns the values that don't exist in the 'missing' structure", ->
-      result.missing.should.eql(['three'])
-
-
-  describe 'length', ->
-
-    it 'returns 0 for empty cache', ->
-      cache.length().should.equal 0
-
-    it 'returns the number of objects in the cache', ->
-      cache.add('foo', 'bar')
-      cache.add('fooz', 'baz')
-      cache.length().should.equal(2)
-
-
-  describe 'replaceAll', ->
-
-    it 'replaces the whole cache with the given data', ->
-      cache.add 'one', 1
-      cache.replaceAll {'one': 2, two: 3}
-      cache.length().should.equal(2)
-      cache.get('one').should.equal(2)
-      cache.get('two').should.equal(3)
-
-    describe 'with 2 parameters', ->
-
-      it 'parses the given array, and indexes on the given key', ->
-        ten = {id: 10, value: 'ten'}
-        twelve = {id: 12, value: 'twelve'}
-
-        cache.replaceAll [ten, twelve], 'id'
-
-        cache.length().should.equal 2
-        cache.get(10).should.equal ten
-        cache.get(12).should.equal twelve
-

data/demo/spec/javascripts/data/indexed_cache_spec.coffee

@@ -1,51 +0,0 @@
-#= require spec_helper
-#= require modularity/data/indexed_cache
-
-
-describe 'IndexedCache', ->
-
-  indexed_cache = null
-  entry_1 = {id: 1, value: 'one'}
-  entry_2 = {id: 2, value: 'two'}
-  beforeEach ->
-    indexed_cache = new modularity.IndexedCache 'id'
-
-
-  describe 'constructor', ->
-    
-    it 'stores the given key attribute', ->
-      indexed_cache.key.should == 'id'
-
-
-  describe 'add', ->
-    
-    beforeEach ->
-      indexed_cache.add entry_1
-
-    it 'adds the given element', ->
-      indexed_cache.cache.length().should.equal 1
-      indexed_cache.cache.cache[1].should.eql entry_1
-
-
-  describe 'add_all', ->
-    it 'adds all the given elements', ->
-      indexed_cache.add_all [entry_1, entry_2]
-      indexed_cache.length().should.equal 2
-      indexed_cache.cache.cache[1].should.eql entry_1
-      indexed_cache.cache.cache[2].should.eql entry_2
-
-
-  describe 'remove', ->
-    it 'removes the given object from the server', ->
-      indexed_cache.add entry_1
-      indexed_cache.remove entry_1
-      indexed_cache.length().should.equal 0
-
-  describe 'get', ->
-    it 'returns the element indexed by the given key', ->
-      indexed_cache.add entry_1
-      indexed_cache.get(1).should.eql entry_1
-
-    it "returns undefined if the element doesn't exist", ->
-      expect(indexed_cache.get(2)).to.be.undefined
-

data/demo/spec/javascripts/data/persistence_manager_spec.coffee

@@ -1,283 +0,0 @@
-#= require spec_helper
-#= require modularity/data/persistence_manager
-#= require jquery
-
-
-describe 'PersistenceManager', ->
-
-  # Global variables for testing.
-  persistence_manager = null
-  entry_1 = {id: 1, value: 'one'}
-  entry_2 = {id: 2, value: 'two'}
-
-  beforeEach ->
-    persistence_manager = new modularity.PersistenceManager {url: '/users'}
-
-
-  describe 'constructor', ->
-
-    it 'initializes an empty server data cache', ->
-      persistence_manager.server_data.length().should.equal 0
-
-    it 'initializes an empty client data cache', ->
-      persistence_manager.client_data.length().should.eql 0
-
-    it 'stores the given base url', ->
-      persistence_manager.base_url.should.equal '/users'
-
-    it 'stores the given index key', ->
-      persistence_manager = new modularity.PersistenceManager {key: 'my_key', url: '/users'}
-      persistence_manager.key.should.equal 'my_key'
-
-    it "uses 'id' as the default if no key is given", ->
-      persistence_manager.key.should.equal 'id'
-
-
-  describe 'add_all', ->
-
-    it 'adds the given data to the server_data cache', ->
-      spy = sinon.spy persistence_manager.server_data, 'add_all'
-      data = [{id: 1}, {id: 2}]
-      persistence_manager.add_all data
-      spy.should.have.been.calledOnce
-
-  describe 'create', ->
-    new_obj = {value: 'foo'}
-
-    beforeEach ->
-      sinon.stub(jQuery, 'ajax').yieldsTo('success', entry_2)
-
-    afterEach ->
-      jQuery.ajax.restore()
-
-    it 'makes an ajax POST request to the CREATE url on the server', ->
-      persistence_manager.create new_obj, ->
-      jQuery.ajax.should.have.been.calledOnce
-      args = jQuery.ajax.args[0][0]
-      args.url.should.equal '/users.json'
-      args.type.should.equal 'POST'
-
-    it 'sends the object as payload', ->
-      persistence_manager.create new_obj, ->
-      args = jQuery.ajax.args[0][0]
-      args.data.should.equal new_obj
-
-    it "doesn't updates the server cache immediately because the object doesn't have an id", ->
-      persistence_manager.create new_obj, ->
-      expect(persistence_manager.server_data.get(1)).to.be.undefined
-
-    it 'updates the server cache with the server data when the call returns', (done) ->
-      persistence_manager.create {value: 'bar'}, (server_obj) ->
-        persistence_manager.server_data.get(server_obj.id).should.equal entry_2
-        done()
-
-    it 'calls the given callback when done', (done) ->
-      persistence_manager.create new_obj, ->
-        done()
-
-
-  describe 'delete', ->
-
-    beforeEach ->
-      sinon.stub(jQuery, 'ajax').yieldsTo('success')
-
-    afterEach ->
-      jQuery.ajax.restore()
-
-    it 'makes an ajax DELETE request to the item url on the server', ->
-      persistence_manager.delete entry_1
-      jQuery.ajax.should.have.been.calledOnce
-      args = jQuery.ajax.args[0][0]
-      args.url.should.equal '/users/1.json'
-      args.type.should.equal 'DELETE'
-
-    it 'removes the object from the client and server cache', ->
-      persistence_manager.server_data.add entry_1
-      persistence_manager.client_data.add entry_1
-      persistence_manager.delete entry_1
-      persistence_manager.server_data.length().should.equal 0
-      persistence_manager.client_data.length().should.equal 0
-
-    it 'calls the given callback when done', (done) ->
-      persistence_manager.delete entry_1, ->
-        done()
-
-
-  describe 'entry_url', ->
-
-    it 'returns the url to access a single entry', ->
-      persistence_manager.entry_url(entry_1).should.equal '/users/1.json'
-
-
-  describe 'load', ->
-
-    describe 'entry exists in client data cache', ->
-      it 'returns the entry from the @client_data cache if it exists there', (done) ->
-        persistence_manager.client_data.add entry_1
-        persistence_manager.load 1, (entry) ->
-          entry.should.equal entry_1
-          done()
-
-    describe 'entry exists in server data cache', ->
-
-      beforeEach ->
-        persistence_manager.server_data.add entry_1
-
-      it 'adds the entry to the client data cache', (done) ->
-        persistence_manager.load 1, ->
-          persistence_manager.client_data.length().should.equal 1
-          persistence_manager.client_data.get(1).should.eql entry_1
-          done()
-
-      it 'returns the entry from the client data cache', (done) ->
-        persistence_manager.load 1, (entry) ->
-          client_cache_entry = persistence_manager.client_data.get 1
-          entry.should.equal client_cache_entry
-          done()
-
-      it 'returns a different hash than the server data, so that the user can make changes to it', (done) ->
-        persistence_manager.load 1, (entry) ->
-          server_cache_entry = persistence_manager.server_data.get 1
-
-          entry.should.not.equal server_cache_entry
-          done()
-
-
-    describe "entry doesn't exist on the client at all", ->
-
-      beforeEach ->
-        sinon.stub(jQuery, 'ajax').yieldsTo('success', entry_1)
-
-      afterEach ->
-        jQuery.ajax.restore()
-
-      it "retrieves the entry from the server", (done) ->
-        persistence_manager.load 1, ->
-          jQuery.ajax.should.have.been.calledOnce
-          done()
-
-
-      it 'stores the entry in the server cache', (done) ->
-        persistence_manager.load 1, ->
-          persistence_manager.server_data.length().should.equal 1
-          persistence_manager.server_data.get(1).should.equal entry_1
-          done()
-
-      it 'stores a replica of the entry in the client cache', (done) ->
-        persistence_manager.load 1, ->
-          persistence_manager.client_data.get(1).should.not.equal entry_1
-          persistence_manager.client_data.get(1).should.eql entry_1
-          done()
-
-      it 'returns the client replica', (done) ->
-        persistence_manager.load 1, (entry) ->
-          persistence_manager.client_data.get(1).should.equal entry
-          persistence_manager.server_data.get(1).should.not.equal entry
-          done()
-
-
-  describe 'load_all', ->
-
-    loading_done_callback = null
-    beforeEach ->
-      sinon.stub(jQuery, 'ajax').yieldsTo('success', [entry_1, entry_2])
-      loading_done_callback = sinon.spy()
-      persistence_manager.load_all loading_done_callback, {'q': 'foo'},
-
-    afterEach ->
-      jQuery.ajax.restore()
-
-    it 'makes a request to the INDEX action of the server', ->
-      jQuery.ajax.should.have.been.calledOnce
-      jQuery.ajax.args[0][0].url.should.equal '/users.json'
-
-    it 'provides the given data as parameters to the request', ->
-      jQuery.ajax.args[0][0].data.should.eql {'q': 'foo'}
-
-    it 'fills the server cache with the response data', ->
-      persistence_manager.server_data.length().should.eql 2
-      persistence_manager.server_data.get(1).should.eql entry_1
-      persistence_manager.server_data.get(2).should.eql entry_2
-
-    it 'calls the given callback method when the data is available', ->
-      loading_done_callback.should.have.been.calledOnce
-
-
-  describe 'load_many', ->
-
-    describe 'all snippets in cache', ->
-      it 'returns an array of all requested snippets', ->
-        persistence_manager.add_all [{id: 1}, {id: 2}, {id: 3}]
-        persistence_manager.load_many [1,2], (snippets) ->
-          expect(snippets).to.have.length 2
-          expect(snippets[0].id).to.equal 1
-          expect(snippets[1].id).to.equal 2
-
-
-    describe 'some snippets are not cached', ->
-
-      it 'loads the missing snippets from the server'
-
-
-  describe 'save', ->
-
-    describe 'for unsaved objects', ->
-      it "calls the 'create' action", ->
-        sinon.stub persistence_manager, 'create'
-        persistence_manager.save {value: 'foo'}, ->
-        persistence_manager.create.should.have.been.calledOnce
-
-    describe 'for objects from the server', ->
-      it "calls the 'update' action", ->
-        sinon.stub persistence_manager, 'update'
-        persistence_manager.save entry_1, ->
-        persistence_manager.update.should.have.been.calledOnce
-
-
-  describe 'update', ->
-
-    beforeEach ->
-      sinon.stub(jQuery, 'ajax').yieldsTo('success', entry_2)
-      server_entry = {id: 1, title: 'server title', desc: 'server desc'}
-      persistence_manager.server_data.add server_entry
-
-    afterEach ->
-      jQuery.ajax.restore()
-
-    it 'makes an ajax PUT request to the UPDATE url on the server', ->
-      persistence_manager.update entry_1, ->
-      jQuery.ajax.should.have.been.calledOnce
-      args = jQuery.ajax.args[0][0]
-      args.url.should.equal '/users/1.json'
-      args.type.should.equal 'PUT'
-
-    it 'sends only updated colums of the object as payload', (done) ->
-      persistence_manager.load 1, (client_entry) ->
-        client_entry.title = 'client title'
-
-        persistence_manager.update client_entry
-
-
-        args = jQuery.ajax.args[0][0]
-        args.data.should.eql {id: 1, title: 'client title'}
-        done()
-
-    it "doesn't perform the call if nothing is changed", (done) ->
-      persistence_manager.load 1, (client_entry) ->
-        persistence_manager.update client_entry
-        jQuery.ajax.should.not.have.been.called
-        done()
-
-    it 'updates the server cache immediately with the given object', ->
-      persistence_manager.update entry_1, ->
-      persistence_manager.server_data.get(1).should.equal entry_1
-
-    it 'updates the server cache with the server object when done', (done) ->
-      persistence_manager.update entry_1, (server_obj) ->
-        persistence_manager.server_data.get(2).should.equal entry_2
-        done()
-
-    it 'calls the given callback when done', (done) ->
-      persistence_manager.update entry_1, ->
-        done()
-