resourcy-rails 1.0.0

data/spec/javascripts/jquery.resourcy_spec.js.coffee

@@ -0,0 +1,399 @@
+require '/assets/jquery-1.8.0.js'
+require '/assets/jquery.resourcy.js'
+require '/assets/jquery_ujs.js'
+
+describe "Resourcy jQuery Adapter (1.8.0)", ->
+
+  beforeEach ->
+    R.removeAll()
+
+  describe "plugin signature", ->
+
+    it "has all the methods it should have", ->
+      expect(typeof($.resources)).toBe('function')
+      expect(typeof($.resource)).toBe('function')
+      expect(typeof($.routes)).toBe('function')
+      expect($.handleRequest).toBeUndefined()
+
+    it "removes Resourcy", ->
+      expect(window.Resourcy).toBeUndefined()
+
+
+  describe "plural resources", ->
+
+    beforeEach ->
+      spyOn(window, 'XMLHttpRequest') # keep these requests from being fully requested
+      @resource = $.resources('blogs/:blog_id/posts').add(RESOURCES.POSTS)
+      @url = '/blogs/1/posts'
+
+    it "handles the index action", ->
+      spy = spyOn(@resource.actions, 'index')
+      $.ajax(@url, {type: 'get'})
+
+      expect(spy.callCount).toBe(1)
+
+    it "handles the show action", ->
+      spy = spyOn(@resource.actions, 'show')
+      $.ajax("#{@url}/1", {type: 'get'})
+
+      expect(spy.callCount).toBe(1)
+
+    it "handles the new action", ->
+      spy = spyOn(@resource.actions, 'new')
+      $.ajax("#{@url}/new", {type: 'get'})
+
+      expect(spy.callCount).toBe(1)
+
+    it "handles the create action", ->
+      spy = spyOn(@resource.actions, 'create')
+      $.ajax(@url, {type: 'post'})
+
+      expect(spy.callCount).toBe(1)
+
+    it "handles the edit action", ->
+      spy = spyOn(@resource.actions, 'edit')
+      $.ajax("#{@url}/1/edit", {type: 'get'})
+
+      expect(spy.callCount).toBe(1)
+
+    it "handles the update action", ->
+      spy = spyOn(@resource.actions, 'update')
+      $.ajax("#{@url}/1", {type: 'put'})
+
+      expect(spy.callCount).toBe(1)
+
+    it "handles the destroy action", ->
+      spy = spyOn(@resource.actions, 'destroy')
+      $.ajax("#{@url}/1", {type: 'delete'})
+
+      expect(spy.callCount).toBe(1)
+
+    it "handles get members", ->
+      spy = spyOn(@resource.actions.get, 'comments')
+      $.ajax("#{@url}/1/comments", {type: 'get'})
+
+      expect(spy.callCount).toBe(1)
+
+    it "handles put members", ->
+      spy = spyOn(@resource.actions.put, 'publish')
+      $.ajax("#{@url}/1/publish", {type: 'put'})
+
+      expect(spy.callCount).toBe(1)
+
+    it "handles post members", ->
+      spy = spyOn(@resource.actions.post, 'reorder')
+      $.ajax("#{@url}/1/reorder", {type: 'post'})
+
+      expect(spy.callCount).toBe(1)
+
+    it "handles delete members", ->
+      spy = spyOn(@resource.actions.delete, 'comments')
+      $.ajax("#{@url}/1/comments", {type: 'delete'})
+
+      expect(spy.callCount).toBe(1)
+
+    describe "ajax arguments", ->
+
+      it "accepts the url in the options object", ->
+        spy = spyOn(@resource.actions, 'index')
+        $.ajax({url: @url, type: 'get'})
+
+        expect(spy.callCount).toBe(1)
+
+      it "falls back to _method if it's provided in the data", ->
+        spy = spyOn(@resource.actions, 'create')
+        data = [{name: '_method', value: 'post'}]
+        $.ajax({url: @url, data: data})
+
+        expect(spy.callCount).toBe(1)
+
+
+  describe "singular resources", ->
+
+    beforeEach ->
+      spyOn(window, 'XMLHttpRequest') # keep these requests from being fully requested
+      @resource = $.resource('blogs/:blog_id/owner').add(RESOURCES.OWNER)
+      @url = '/blogs/1/owner'
+
+    it "handles the show action", ->
+      spy = spyOn(@resource.actions, 'show')
+      $.ajax(@url, {type: 'get'})
+
+      expect(spy.callCount).toBe(1)
+
+    it "handles the new action", ->
+      spy = spyOn(@resource.actions, 'new')
+      $.ajax("#{@url}/new", {type: 'get'})
+
+      expect(spy.callCount).toBe(1)
+
+    it "handles the create action", ->
+      spy = spyOn(@resource.actions, 'create')
+      $.ajax(@url, {type: 'post'})
+
+      expect(spy.callCount).toBe(1)
+
+    it "handles the edit action", ->
+      spy = spyOn(@resource.actions, 'edit')
+      $.ajax(@url + '/edit', {type: 'get'})
+
+      expect(spy.callCount).toBe(1)
+
+    it "handles the update action", ->
+      spy = spyOn(@resource.actions, 'update')
+      $.ajax(@url, {type: 'put'})
+
+      expect(spy.callCount).toBe(1)
+
+    it "handles the destroy action", ->
+      spy = spyOn(@resource.actions, 'destroy')
+      $.ajax(@url, {type: 'delete'})
+
+      expect(spy.callCount).toBe(1)
+
+    it "handles get members", ->
+      @resource.add('get:blogs', ->)
+      spy = spyOn(@resource.actions.get, 'blogs')
+      $.ajax("#{@url}/blogs", {type: 'get'})
+
+      expect(spy.callCount).toBe(1)
+
+    it "handles put members", ->
+      @resource.add('put:demote', ->)
+      spy = spyOn(@resource.actions.put, 'demote')
+      $.ajax("#{@url}/demote", {type: 'put'})
+
+      expect(spy.callCount).toBe(1)
+
+    it "handles post members", ->
+      @resource.add('post:blogs', ->)
+      spy = spyOn(@resource.actions.post, 'blogs')
+      $.ajax("#{@url}/blogs", {type: 'post'})
+
+      expect(spy.callCount).toBe(1)
+
+    it "handles delete members", ->
+      @resource.add('delete:blog', ->)
+      spy = spyOn(@resource.actions.delete, 'blog')
+      $.ajax("#{@url}/blog", {type: 'delete'})
+
+      expect(spy.callCount).toBe(1)
+
+
+  describe "callbacks", ->
+
+    beforeEach ->
+      @resource = $.resources('blogs/:blog_id/posts')
+      @url = '/blogs/1/posts'
+      @callback = -> 'callback'
+
+    describe "passed arguments", ->
+
+      beforeEach ->
+        spyOn(window, 'XMLHttpRequest') # keep these requests from being fully requested
+        @resource.add('index', => {success: @callback})
+        @actionSpy = spyOn(@resource.actions, 'index').andCallThrough()
+
+      it "passes the proceed function", ->
+        $.ajax('/blogs/1/posts', {type: 'get'})
+
+        expect(typeof(@actionSpy.argsForCall[0][0])).toEqual('function')
+
+      it "passes parsed path variables with their values", ->
+        $.ajax('/blogs/42/posts', {type: 'get'})
+
+        expect(@actionSpy.argsForCall[0][1]).toEqual({blog_id: '42'})
+
+      it "passes the requests url parts", ->
+        $.ajax('http://jejacks0n:password@localhost:3000/blogs/42/posts.json?foo=bar#hash', {type: 'get'})
+
+        expect(@actionSpy.argsForCall[0][2]).toEqual
+          scheme: 'http'
+          credentials: 'jejacks0n:password'
+          host: 'localhost'
+          port: '3000'
+          path: '/blogs/42/posts'
+          action: 'posts'
+          format: 'json'
+          query: 'foo=bar'
+          hash: 'hash'
+
+
+    describe "returning values", ->
+
+      it "allows returning options that will be used for the request", ->
+        @resource.add('index', => {success: @callback})
+        spy = spyOn(@, 'callback')
+
+        runs -> $.ajax(@url, {type: 'get'})
+        waitsFor -> spy.callCount
+
+        runs -> expect(spy.callCount).toBe(1)
+
+      it "handles the complete callback", ->
+        @resource.add('index', => {success: @callback, complete: @callback})
+        spy = spyOn(@, 'callback')
+
+        runs -> $.ajax(@url, {type: 'get'})
+        waitsFor -> spy.callCount == 2
+
+        runs -> expect(spy.callCount).toBe(2)
+
+      it "handles the beforeSend callback", ->
+        spyOn(window, 'XMLHttpRequest') # keep these requests from being fully requested
+        @resource.add('index', => {beforeSend: @callback})
+        spy = spyOn(@, 'callback')
+
+        $.ajax(@url, {type: 'get'})
+
+        expect(spy.callCount).toBe(1)
+
+      it "handles the dataFilter callback", ->
+        @resource.add('index', => {dataFilter: @callback})
+        spy = spyOn(@, 'callback')
+
+        runs -> $.ajax(@url, {type: 'get', dataType: 'json'})
+        waitsFor -> spy.callCount
+
+        runs -> expect(spy.argsForCall[0][1]).toBe('json')
+
+      it "handles the error callback", ->
+        @resource = $.resources('blogs')
+        @resource.add('index', => {error: @callback})
+        spy = spyOn(@, 'callback')
+
+        runs -> $.ajax('/blogs', {type: 'get'})
+        waitsFor -> spy.callCount
+
+        runs -> expect(spy.callCount).toBe(1)
+
+      describe "and proceeding", ->
+
+        it "proceeds when you return an object", ->
+          @resource.add('index', => {success: @callback})
+          spy = spyOn(@, 'callback')
+
+          runs -> $.ajax(@url, {method: 'get'})
+          waitsFor -> spy.callCount
+
+          runs -> expect(spy.callCount).toBe(1)
+
+        it "doesn't proceed when proceed is called", ->
+          @resource.add('index', (proceed) => proceed({success: @callback}))
+          spy = spyOn(@, 'callback')
+
+          runs -> $.ajax(@url, {method: 'get'})
+          waitsFor -> spy.callCount
+
+          runs -> expect(spy.callCount).toBe(1)
+
+        it "doesn't proceed when returning false", ->
+          spy = spyOn(@, 'callback').andCallFake(-> false)
+          ajaxSpy = spyOn($, 'originalAjax')
+          @resource.add('index', @callback)
+          $.ajax(@url, {method: 'get'})
+
+          expect(ajaxSpy.callCount).toBe(0)
+
+        it "doesn't call proceed more than once", ->
+          @resource.add 'index', (proceed) =>
+            proceed({success: @callback})
+            return {success: @callback}
+          spy = spyOn(@, 'callback')
+
+          runs -> $.ajax(@url, {method: 'get'})
+          waitsFor -> spy.callCount
+
+          runs -> expect(spy.callCount).toBe(1)
+
+  describe "chained callbacks", ->
+
+    beforeEach ->
+      @resource = $.resources('blogs/:blog_id/posts')
+      @url = '/blogs/1/posts'
+      @callback = -> 'callback'
+
+    it "calls both success callbacks", ->
+      @resource.add('index', => {success: @callback})
+      spy = spyOn(@, 'callback')
+
+      runs -> $.ajax(@url, {method: 'get', success: @callback})
+      waitsFor -> spy.callCount == 2
+
+      runs -> expect(spy.callCount).toBe(2)
+
+    it "calls both beforeSend callbacks", ->
+      spyOn(window, 'XMLHttpRequest') # keep these requests from being fully requested
+      @resource.add('index', => {beforeSend: @callback})
+      spy = spyOn(@, 'callback')
+
+      $.ajax(@url, {type: 'get', beforeSend: @callback})
+
+      expect(spy.callCount).toBe(2)
+
+    it "calls both dataFilter callbacks", ->
+      @resource.add('index', => {dataFilter: @callback})
+      spy = spyOn(@, 'callback')
+
+      runs -> $.ajax(@url, {type: 'get', dataType: 'json', dataFilter: @callback})
+      waitsFor -> spy.callCount == 2
+
+      runs -> expect(spy.argsForCall[1][1]).toBe('json')
+
+    it "calls both complete callbacks", ->
+      @resource.add('index', => {complete: @callback})
+      spy = spyOn(@, 'callback')
+
+      runs -> $.ajax(@url, {type: 'get', dataType: 'json', complete: @callback})
+      waitsFor -> spy.callCount == 2
+
+      runs -> expect(spy.callCount).toBe(2)
+
+    it "calls both error callbacks", ->
+      @resource = $.resources('blogs')
+      @resource.add('index', => {error: @callback})
+      spy = spyOn(@, 'callback')
+
+      runs -> $.ajax('/blogs', {method: 'get', error: @callback})
+      waitsFor -> spy.callCount == 2
+
+      runs -> expect(spy.callCount).toBe(2)
+
+    it "allows mixing $.ajax().done() style callbacks", ->
+      @resource.add('index', => {success: @callback})
+      spy = spyOn(@, 'callback')
+
+      runs -> $.ajax(@url, {method: 'get'}).done(@callback)
+      waitsFor -> spy.callCount == 2
+
+      runs -> expect(spy.callCount).toBe(2)
+
+
+  describe "using UJS", ->
+
+    template 'ujs.html'
+
+    beforeEach ->
+      @resource = $.resources('posts')
+      @callback = -> 'callback'
+
+    it "allows :remote => true", ->
+      spyOn(window, 'XMLHttpRequest') # keep these requests from being fully requested
+      spy = spyOn(@, 'callback')
+      @resource.add('show', @callback)
+      @resource.add('edit', @callback)
+
+      $('a#show').click()
+      expect(spy.callCount).toBe(1)
+
+      $('a#edit').click()
+      expect(spy.callCount).toBe(2)
+
+    it "allows :remote => true to call callbacks", ->
+      spy = spyOn(@, 'callback')
+      @resource.add('show', => {success: @callback})
+
+      runs -> $('a#show').click()
+      waitsFor -> spy.callCount
+
+      runs -> expect(spy.callCount).toBe(1)

data/spec/javascripts/resourcy_spec.js.coffee

@@ -0,0 +1,177 @@
+require '/assets/resourcy.js'
+
+describe "Resourcy", ->
+
+  beforeEach ->
+    Resourcy.removeAll()
+
+  describe ".resources (creating a plural resource)", ->
+
+    beforeEach ->
+      @resource = Resourcy.resources('blogs/:blog_id/posts')
+
+    it "returns a resource", ->
+      expect(typeof(@resource)).toBe('object')
+
+    it "sets information on the resource", ->
+      expect(@resource.pathvars).toEqual(['blog_id'])
+      expect(@resource.actions).toEqual({})
+      expect(@resource.singular).toBe(false)
+      expect(@resource.name).toBe('posts')
+
+    it "has an add, remove, and describe method", ->
+      expect(typeof(@resource.add)).toBe('function')
+      expect(typeof(@resource.remove)).toBe('function')
+      expect(typeof(@resource.describe)).toBe('function')
+
+    it "can find an existing resource and return it", ->
+      r2 = Resourcy.resources('blogs/:blog_id/posts')
+      expect(r2).toBe(@resource)
+
+
+  describe ".resource (creating a singular resource)", ->
+
+    beforeEach ->
+      @resource = Resourcy.resource('blogs/:blog_id/owner')
+
+    it "returns a resource", ->
+      expect(typeof(@resource)).toBe('object')
+
+    it "sets information on the resource", ->
+      expect(@resource.pathvars).toEqual(['blog_id'])
+      expect(@resource.actions).toEqual({})
+      expect(@resource.singular).toBe(true)
+      expect(@resource.name).toBe('owner')
+
+    it "has an add, remove, and describe method", ->
+      expect(typeof(@resource.add)).toBe('function')
+      expect(typeof(@resource.remove)).toBe('function')
+      expect(typeof(@resource.describe)).toBe('function')
+
+    it "can find an existing resource and return it", ->
+      r2 = Resourcy.resource('blogs/:blog_id/owner')
+
+      expect(r2).toBe(@resource)
+
+
+  describe ".routes", ->
+
+    beforeEach ->
+      Resourcy.resources('blogs/:blog_id/posts')
+      Resourcy.resource('blogs/:blog_id/owner')
+
+    it "returns an object of registered resources", ->
+      expect(Resourcy.routes()).toEqual({owner: [], posts: []})
+
+    it "calls describe on all the resources", ->
+      spyOn(Resourcy.resources('blogs/:blog_id/posts'), 'describe').andCallFake(-> ['posts => foo'])
+      spyOn(Resourcy.resources('blogs/:blog_id/owner'), 'describe').andCallFake(-> ['owner => foo'])
+
+      expect(Resourcy.routes()).toEqual({owner: ['owner => foo'], posts: ['posts => foo']})
+
+
+  describe ".noConflict", ->
+
+    it "removes Resourcy", ->
+      Resourcy.noConflict() # in specs we've overridden noConflict to assign it to R (and remove it like normal)
+
+      expect(window.Resourcy).toBeUndefined()
+      window.Resourcy = window.R # and put it back now
+
+
+  describe "plural resources", ->
+
+    beforeEach ->
+      @resource = Resourcy.resources('blogs/:blog_id/posts')
+      @callback = -> 'callback'
+
+    describe "#add", ->
+
+      it "accepts an object, and adds to the actions", ->
+        @resource.add({index: @callback})
+
+        expect(@resource.actions.index).toBe(@callback)
+
+      it "accepts an string and callback, and adds to the actions", ->
+        @resource.add('put:activate', @callback)
+
+        expect(@resource.actions.put['activate']).toBe(@callback)
+
+      it "doesn't allow adding the same action more than once", ->
+        @resource.add({index: @callback})
+
+        expect(=> @resource.add({index: @callback}))
+          .toThrow("The index action already exists on the 'posts' resource. Try removing it first.")
+
+      it "returns itself for chaining", ->
+        expect(@resource.add('put:activate', @callback)).toBe(@resource)
+
+
+    describe "#remove", ->
+
+      beforeEach ->
+        @resource.add('index', @callback)
+        @resource.add('put:activate', @callback)
+
+      it "removes the action", ->
+        expect(@resource.actions.index).toBe(@callback)
+        expect(@resource.actions.put['activate']).toBe(@callback)
+
+        @resource.remove('index')
+        @resource.remove('put:activate')
+
+        expect(@resource.actions.index).toBeUndefined()
+        expect(@resource.actions.put['activate']).toBeUndefined()
+
+      it "returns itself for chaining", ->
+        expect(@resource.remove('index')).toBe(@resource)
+
+
+    describe "#removeAll", ->
+
+      beforeEach ->
+        @resource.add('index', @callback)
+        @resource.add('put:activate', @callback)
+
+      it "clears all actions", ->
+        expect(@resource.actions.index).toBe(@callback)
+        expect(@resource.actions.put['activate']).toBe(@callback)
+
+        @resource.removeAll()
+
+        expect(@resource.actions).toEqual({})
+
+      it "returns itself for chaining", ->
+        expect(@resource.removeAll()).toBe(@resource)
+
+
+    describe "#describe", ->
+
+      beforeEach ->
+        @resource.add('index', @callback)
+        @resource.add('put:activate', @callback)
+
+      it "returns an array describing the resource actions", ->
+        expect(@resource.describe()).toEqual(['blogs/:blog_id/posts/activate PUT => posts#activate', 'blogs/:blog_id/posts GET => posts#index'])
+
+
+  describe "singular resources", ->
+
+    beforeEach ->
+      @resource = Resourcy.resource('blogs/:blog_id/owner')
+      @callback = -> 'callback'
+
+    describe "#add", ->
+
+      it "doesn't allow adding the index action", ->
+        expect(=> @resource.add('index')).toThrow("Adding index to 'owner' isn't possible (singular resource).")
+
+
+    describe "#describe", ->
+
+      beforeEach ->
+        @resource.add('show', @callback)
+        @resource.add('put:activate', @callback)
+
+      it "returns an array describing the resource actions", ->
+        expect(@resource.describe()).toEqual(['blogs/:blog_id/owner/activate PUT => owner#activate', 'blogs/:blog_id/owner GET => owner#show'])

data/spec/javascripts/spec_helper.js

@@ -0,0 +1,37 @@
+RESOURCES = {
+  POSTS: {
+    'index':           function() { return 'PostsController#index' },
+    'show':            function() { return 'PostsController#show' },
+    'new':             function() { return 'PostsController#new' },
+    'create':          function() { return 'PostsController#create' },
+    'edit':            function() { return 'PostsController#edit' },
+    'update':          function() { return 'PostsController#update' },
+    'destroy':         function() { return 'PostsController#destroy'},
+    'get:comments':    function() { return 'PostsController#comments:GET' },
+    'post:reorder':    function() { return 'PostsController#reorder:POST' },
+    'delete:comments': function() { return 'PostsController#comments:DELETE' },
+    'put:publish':     function() { return 'PostsController#publish:PUT' }
+  },
+  COMMENTS: {
+    'index':           function() { return 'CommentsController#index' },
+    'new':             function() { return 'CommentsController#new' },
+    'create':          function() { return 'CommentsController#create' },
+    'destroy':         function() { return 'CommentsController#destroy' },
+    'put:approve':     function() { return 'CommentsController#publish:PUT' }
+  },
+  OWNER: {
+    'show':            function() { return 'OwnerController#show' },
+    'new':             function() { return 'OwnerController#new' },
+    'create':          function() { return 'OwnerController#create' },
+    'edit':            function() { return 'OwnerController#edit' },
+    'update':          function() { return 'OwnerController#update' },
+    'destroy':         function() { return 'OwnerController#destroy'},
+  }
+};
+
+window.Resourcy = {
+  noConflict: function() {
+    window.R = Resourcy;
+    delete(window.Resourcy);
+  }
+};

data/spec/javascripts/templates/ujs.html

@@ -0,0 +1,3 @@
+<a id="show" href="/posts/1" data-remote="true">Show</a>
+<a id="edit" href="/posts/1/edit" data-remote="true">Edit</a>
+<a id="destroy" href="/posts/1" data-confirm="Are you sure?" data-method="delete" data-remote="true" rel="nofollow">Destroy</a>

data/vendor/assets/javascripts/jquery.resourcy.js.coffee

@@ -0,0 +1,37 @@
+#= require resourcy
+#
+# Resourcy Ajax adapter
+#
+# This overrides the default jQuery.ajax method and mixes in the logic required to make Resourcy work with the options
+# and arguments for the jQuery Ajax api.
+
+# Get the original jQuery.ajax and merge in some additional methods from Resourcy.
+original = jQuery.ajax
+jQuery.extend(jQuery, {originalAjax: original, resources: Resourcy.resources, resource: Resourcy.resource, routes: Resourcy.routes})
+
+# Remove Resourcy from the global namespace.
+handleRequest = Resourcy.handleRequest
+Resourcy.noConflict()
+
+# Define an options handler, that properly merges options for the Ajax request.
+optionsHandler = (opts1, opts2) ->
+  options = jQuery.extend(true, {}, opts1, opts2)
+  for method in ['beforeSend', 'error', 'dataFilter', 'success', 'complete']
+    if opts1[method] && opts2[method]
+      c1 = opts1[method]
+      c2 = opts2[method]
+      options[method] = ->
+        c1.apply(window, arguments)
+        c2.apply(window, arguments)
+  return options
+
+# Create a new jQuery.ajax method that works with Resourcy.
+jQuery.ajax = (url, options = {}) ->
+  if typeof(url) is 'object'
+    options = url
+    url = options.url
+  for data in options.data || []
+    if data.name is '_method'
+      method = data.value
+      break
+  return handleRequest(method || options.type || 'get', url, options, jQuery.originalAjax, optionsHandler)