ajax_pagination 0.2.0 → 0.3.0

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+## v0.3.0
+* Class method ajax_pagination :reload option - a string in json form no longer accepted, pass it in as a hash or array of hashes instead
+* image option added to ajax_pagination view helper, to specify a loading image other than the default
+* For reloading of a page section on browser back/forward, urlregex urlparts option changed to parse the url in strict mode
+* Fixed bug: The loading never stopped if page was invalid, it will now display the error page properly
+* Fixed bug: back/forward not loading properly in certain cases
+* AJAX Pagination now uses jquery-ujs! The internals have changed, but the released public API has not otherwise changed. However, this important change allows AJAX Pagination to handle links and forms requesting via POST, PUT and DELETE methods.
+* Added link helper ajax_link_to, which wraps link_to. This helper is useful for one-off links to perform an AJAX call. In fact, the output link format that required to get AJAX Pagination to work.
+* The original way to specify that links use AJAX Pagination - wrapping links within a container of ajaxpagination class, with data-pagination attribute is now a convenience feature provided, which actually uses javascript to set the same link attributes as the link helper.
+* Added support for redirection - redirects are intercepted, and if they are AJAX calls with a pagination url parameter, will be modified into a Status 200 OK response with Location header. The AJAX call be manually follow the redirect, and update the url in the address bar. the pagination url parameter context can also be kept.
+* Add support for changing page title in the returned AJAX partial which is better if using for site-wide navigation (before it simply preserved the previous title)
+* Scrolling feature fixed, and a new configuration - scroll_margin provided
+* Added form helpers which trigger ajax pagination
+* Added ajax_options method, which can be used especially with form helpers from gems such as Formtastic or Simple Form.
+* Added specs for new features (including displaying error pages, redirecting within div, submitting forms with PUT POST DELETE, testing ajax_link_to, ajax_form_tag, ajax_form_for (and with all these, indirectly testing ajax_options), title changes)
+
 ## v0.2.0
 **Note: The API has changed slightly from previous versions. If you have used an advanced feature - the :partial option, please use :render now, and if used in a controller, a non-partial template will be used. To use a partial, specify :render => { :partial => "" }.**
 

data/README.md

@@ -1,21 +1,11 @@
 # AJAX Pagination
 [![Build Status](https://secure.travis-ci.org/ronalchn/ajax_pagination.png?branch=master)](http://travis-ci.org/ronalchn/ajax_pagination)
 
-Handles AJAX pagination for you, by hooking up the links you want to load content with javascript in designated page containers. Each webpage can have multiple page containers, each with a different set of pagination links. The page containers can be nested. Degrades gracefully when javascript is disabled.
-
-## Introduction
-This gem can ajaxify any pagination solution. Links wrapped in containers with specific classes will be ajaxified. This means that clicking it will instead send an AJAX request for the page in javascript format. The result will replace the content in a container for the content. this gem is tested to work with will_paginate, but should work for other pagination solutions, as well as navigation level links or tabbed interfaces. The ajax call will load new content into the designated content container.
-
-Please note, this is not a pagination solution by itself. You should use a pagination solution such as will_paginate and Kaminari, or a menu builder such as Simple-navigation or Semantic-menu, or you can roll your own. After that is implemented, you can use AJAX Pagination to ajaxify it, so that when users change pages, they do not have the reload the whole page.
-
-## Background
-This gem depends on Rails 3.1+, jQuery and jquery-historyjs. The gem was extracted from http://github.com/xrymbos/nztrain-v2/, and further development will be tied to the needs of the application. Therefore, some dependencies are because the application uses a particular version of these other gems. If you need to use this in other versions/javascript frameworks, I would welcome any pull requests. They are not currently supported because I do not need to use this gem in those other frameworks.
+[Wiki](https://github.com/ronalchn/ajax_pagination/wiki) | [RDoc](http://rdoc.info/gems/ajax_pagination/frames) | [Changelog](https://github.com/ronalchn/ajax_pagination/blob/master/CHANGELOG.md)
 
-The original AJAX pagination functionality was inspired by the RailsCasts on pagination with AJAX. However, other functionality was added to the pagination, and more modular code was desired, especially when many different controllers need pagination. Added functionality includes loading cues and support of multiple pagination areas on the same webpage.
-
-Because the code became more modular, it also made it suitable to turn into a Ruby Gem, so that others can create AJAX pagination without fiddling with the details.
+Handles AJAX pagination for you, by hooking up the links you want to load content with javascript in designated page containers. Each webpage can have multiple page containers, each with a different set of pagination links. The page containers can be nested. Degrades gracefully when javascript is disabled.
 
-Rails 3.1+ is required only because the javascript is placed into the assets pipeline.
+For more, see [Introduction and Background](https://github.com/ronalchn/ajax_pagination/wiki/Introduction-and-Background).
 
 ## Installation
 Add to your Gemfile:
@@ -34,14 +24,15 @@ AJAX Pagination depends on jquery-rails and jquery-historyjs, so if their javasc
 
 ```javascript
 //= require jquery
+//= require jquery_ujs
 //= require history
 ```
 
 ## Getting Started
 The next section presents the usage of the functions in detail. However, it also presents the different options that can be chosen. For a simpler overview of how you can easily use this gem, please read one of the more specific guides below (found in the wiki):
 
-* [Add AJAX to will_paginate](https://github.com/ronalchn/ajax_pagination/wiki/Adding-AJAX-to-will_paginate)
-* [Add AJAX to site navigation](https://github.com/ronalchn/ajax_pagination/wiki/Adding-AJAX-to-site-navigation)
+* [Adding AJAX to will_paginate](https://github.com/ronalchn/ajax_pagination/wiki/Adding-AJAX-to-will_paginate)
+* [Adding AJAX to site navigation](https://github.com/ronalchn/ajax_pagination/wiki/Adding-AJAX-to-site-navigation)
 
 and much [more](https://github.com/ronalchn/ajax_pagination/wiki/Home).
 
@@ -77,12 +68,14 @@ This will cause it to display content in the _mypartial.* view.
 
 If you are using will_paginate, and the links are wrapped in a div with class="pagination", the links will be ajaxified automatically.
 
-Otherwise, you should wrap the links with a container. We recommend that the class given is "ajaxpagination". You can put the links inside the partial, for example:
+Otherwise, you can wrap a set of links with a container. We recommend that the class given is "ajaxpagination". You can put the links inside the partial, for example:
 
 ```html
 <div class="ajaxpagination"><a href="#">My ajaxified link</a></div>
 ```
 
+If you want to ajaxify individual links, check out the ajax_link_to helper (shown later), which is more flexible (can handle non-GET requests). Wrapping links in a container is actually just a convenience feature, which internally does the same things ajax_link_to does.
+
 If you are using will_paginate, you can simply put the links inside the partial (so that the new links get reloaded when the page changes):
 
 ```erb
@@ -196,7 +189,7 @@ AJAX Pagination can also add a loading image and partially blanking out of the p
 
 Links outside are still clickable (such as the will_paginate links).
 
-The loading image is currently an image asset at "ajax-loader.gif", so put your loading image there. You can specify a new default filename in your initializer.
+The loading image is currently an image asset at "ajax-loader.gif", so put your loading image there. You can specify a new default filename in your initializer. If you want a different loading image (other than configuring a site-wide default), you can pass an option :image => "newimageinassetpipeline.gif" to the ajax_pagination view helper method.
 
 If you want all the content in the partial (or otherwise wrapped by the ajax_pagination helper method) to be included as a loading zone (with the visual loading cues), you can instead, set the :loadzone option to true, eg:
 
@@ -208,7 +201,7 @@ If you want all the content in the partial (or otherwise wrapped by the ajax_pag
 
 In this case, whatever is inside the yield will not need to call ajax_pagination_loadzone.
 
-### Content reloading
+### Browser History
 
 The back and forward buttons on your browser may not work properly yet. It will work as long as the link includes distinct query parameter with the same name as the pagination name for the set. For example, if the name of the pagination set is "page" (the default), when the browser url changes, AJAX Pagination looks for a change in the links query parameter with the same name, such as if the url changes from /path/to/controller?page=4 to /path/to/controller?page=9, then AJAX Pagination knows that the content corresponding to the pagination set needs reloading. The absence of the parameter is a distinct state, so changes such as /path/to/controller to /path/to/controller?page=0 are detected.
 
@@ -234,12 +227,51 @@ For more flexibility, a number of conditions can be passed in an array. If any o
 <%= ajax_pagination :reload => [{:urlregex => "page=([0-9]+)", :regexindex => 1},{:query => "watching"}] %>
 ```
 
-Instead of passing in the Array/Hash Ruby object, a string in json form is accepted:
+Sometimes, you may have a small section of the page which is paginated, but for which you do not want to change the url. In effect, the page you are on should remain the same, simply with a cool effect, which changes the content displayed. This would mean that the new content loaded does not add to browser history.
+
+By default, the url does get changed, and browser history is added to. To turn this off, you can set :history => false, eg:
 
 ```erb
-<%= ajax_pagination :reload => '[{"urlregex":"page=([0-9]+)","regexindex":1},{"query":"page"}]' %>
+<%= ajax_pagination :history => false %>
 ```
 
+When history is turned off, by default, reload is also set to never reload the content.
+
+### Link and Form helpers
+For individual links, you can ajaxify them using ajax_link_to with the same format as the link_to helper, but making sure to pass a pagination option:
+
+```erb
+<%= ajax_link_to "Name", posts_url, :pagination => "page" %>
+```
+
+Similarly, there exist AJAX form helpers, again with the same format as the original form helpers:
+
+```erb
+<%= ajax_form_tag posts_url, :method => "post", :class => "myclass", :pagination => "page" do %>
+ ...
+<% end %>
+
+<%= ajax_form_for @post, :method => "post", :html => {:class => "myclass", :pagination => "menu"} do %>
+ ...
+<% end %>
+```
+
+Note that these form helpers actually use another helper method ajax_options, with the original non-ajax helpers. This means that you can also use:
+
+```erb
+<%= link_to "Name", posts_url, ajax_options :pagination => "page" %>
+
+<%= form_tag posts_url, ajax_options :method => "post", :class => "myclass", :pagination => "page" do %>
+ ...
+<% end %>
+
+<%= form_for @post, :method => "post", :html => ajax_options({:class => "myclass", :pagination => "menu"}) do %>
+ ...
+<% end %>
+```
+
+This is actually a powerful feature, because though you would simply use the ajax_link_to, ajax_form_tag, ajax_form_for tags as shorthand, if you are using another helper method (eg. one from Formtastic or Simple Form gems), you can use ajax_options with that helper method.
+
 ### Initializer
 You can configure AJAX Pagination in the initializer. Run ```
 rails generate ajax_pagination:install

data/lib/ajax_pagination.rb

@@ -12,6 +12,16 @@ module AjaxPagination
   mattr_accessor :warnings
   @@warnings = nil # if nil, uses default, which is true only in development mode
 
+  # intercepts any AJAX Pagination 302 redirects, and turns them into Status 200 OK, with a Location: header. AJAX code can manually perform the redirection.
+  # can be disabled in the initializer
+  mattr_accessor :redirect_after_filter
+  @@redirect_after_filter = true
+
+  # when changing pages, AJAX Pagination scrolls to ensure the page sees the top of the changing section, plus an additional margin in pixels
+  # to turn this feature off, set scroll_margin to '-Infinity'
+  mattr_accessor :scroll_margin
+  @@scroll_margin = 20
+
   # run rails generate ajax_pagination:install to create a default initializer with configuration values
   def self.config
     yield self

data/lib/ajax_pagination/controller_additions.rb

@@ -18,10 +18,11 @@ module AjaxPagination
         pagination = options[:pagination] || ""
         view = options[:render] || nil
         define_method(:default_render) do |*args|
-          if params[:pagination] && params[:pagination] == pagination && request.format == "html" # override if calling AJAX Pagination
+          paramspagination = request.GET[:pagination] || params[:pagination]
+          if paramspagination && paramspagination == pagination && request.format == "html" # override if calling AJAX Pagination
             unless view
-              if lookup_context.find_all("#{params[:controller]}/_#{params[:pagination]}").any?
-                view = { :partial => params[:pagination] } # render partial, layout is off
+              if lookup_context.find_all("#{params[:controller]}/_#{paramspagination}").any?
+                view = { :partial => paramspagination } # render partial, layout is off
               else
                 view = { :layout => false } # render default view, but turn off layout
               end
@@ -74,11 +75,12 @@ module AjaxPagination
     #     end
     #
     def ajax_pagination(format,options = {})
-      if params[:pagination] == (options[:pagination] || 'page').to_s
+      paramspagination = request.GET[:pagination] || params[:pagination]
+      if paramspagination == (options[:pagination] || 'page').to_s
         if options[:render]
           view = options[:render] # render non partial
-        elsif lookup_context.find_all(params[:controller] + "/_" + params[:pagination]).any?
-          view = {:partial => params[:pagination]} # render partial of the same name as pagination
+        elsif lookup_context.find_all(params[:controller] + "/_" + paramspagination).any?
+          view = {:partial => paramspagination} # render partial of the same name as pagination
         else # render usual view
           view = {}
         end
@@ -125,7 +127,27 @@ module AjaxPagination
     #
     # The heavy computation will only be performed on posts which will be displayed when AJAX Pagination only wants a partial.
     def ajax_pagination_displayed?(pagination = :page)
-      (!request.format.html?) || (params[:pagination].nil?) || (params[:pagination] == pagination.to_s)
+      paramspagination = request.GET[:pagination] || params[:pagination]
+      (!request.format.html?) || (paramspagination.nil?) || (paramspagination == pagination.to_s)
+    end
+
+    # This after_filter method is automatically included by AJAX Paginate, and does not need to be included manually. However,
+    # it can be disabled in the initializer, and if desired, enabled in specific controllers by adding this method as an after_filter.
+    #
+    # This after_filter method will intercept any redirects for AJAX calls by
+    # AJAX Paginate, and turn it into a Status 200 OK response, with an extra Location: header.
+    #
+    # This is used because of the transparent redirection otherwise done by browsers on receiving a 30x status code. The AJAX
+    # code cannot then detect that the request was redirected, and is therefore unable to change the url in the History object.
+    # AJAX Pagination javascript code will detect any 200 OK responses with a Location header, and treat this as a redirection.
+    #
+    # This filter should not affect other uses, because only AJAX calls trigger this. In addition, a ?pagination= parameter is required.
+    # Therefore other AJAX libraries or usage otherwise should not be affected.
+    def ajax_pagination_redirect
+      paramspagination = request.GET[:pagination] || params[:pagination]
+      if request.xhr? && paramspagination && response.status==302 # alter redirect response so that it can be detected by the client javascript
+        response.status = 200 # change response to OK, location header is preserved, so AJAX can get the new page manually
+      end
     end
   end
 end

data/lib/ajax_pagination/helper_additions.rb

@@ -73,21 +73,37 @@ module AjaxPagination
     #   
     #   If nil, AJAX Pagination acts as if it was passed {:query => options [:pagination]}.
     #
+    # [:+image+]
+    #   Specify another image to be used as the loading image. The string passed is an image in the assets pipeline.
+    #   If not specified, the default loading image is used.
+    #
     # [:+loadzone+]
     #   Instead of using the ajax_pagination_loadzone tag, this option can be set to true. Everything inside this tag
     #   will then be regarded as a loading zone, and the visual loading cues will apply to all the content here.
     #
+    # [:+history+]
+    #   Whether the url changes, as if an new page was accessed, including adding page to the history. This defaults to
+    #   true. Therefore, (sub)pages accessed through AJAX Pagination act as if a whole new page was accessed.
+    #
+    #   If false then it is as if no new page is accessed, and the history is not changed. It therefore appears as if following
+    #   the link simply creates a cool AJAX effect on the current page. If false, then :reload defaults to {:urlregex => ""},
+    #   meaning that it will never reload when browser back/forward buttons are used, whether the url changes or not.
+    #
     def ajax_pagination(options = {})
       pagination = options[:pagination] || 'page' # by default the name of the pagination is 'page'
       partial = options[:render] || pagination # default partial rendered is the name of the pagination
-      reload = options[:reload]
       divoptions = { :id => "#{pagination}_paginated_section", :class => "paginated_section" }
-      case reload.class.to_s
-      when "String"
-        divoptions["data-pagination"] = reload
+      data = {};
+      if options.has_key? :history
+        data[:history] = (options[:history] != false)
+        data[:reload] = {:urlregex => ""} unless data[:history] # by default never reloads a history-less section
+      end
+      case options[:reload].class.to_s
       when "Hash", "Array"
-        divoptions["data-pagination"] = reload.to_json
+        data[:reload] = options[:reload]
       end
+      data[:image] = asset_path options[:image] if options[:image].class.to_s == "String"
+      divoptions["data-pagination"] = data.to_json if !data.empty?
       if options[:loadzone]
         divoptions[:class] = "paginated_section paginated_content"
         divoptions[:style] = "position: relative;"
@@ -105,11 +121,11 @@ module AjaxPagination
     # is reloaded, it may take some time. In the meanwhile, AJAX Pagination will look in the partial amoung its
     # immediate child for this tag. If this tag exists, it will cover this tag with a semi-transparent
     # rectangle, and make the old partial unclickable (links and other elements are therefore disabled).
-    # A loading image is also displayed above the content.
+    # A loading image is also displayed above the content. Only one loading zone is allowed. The rest are ignored.
     #
     # Use this tag in your partial, wrapped around all the content you want to disable. For example, if you are
     # displaying pagination links which you do not want to disable, as well as content you wish to disable,
-    # you partial might contain:
+    # your partial might contain:
     #
     #   <%= will_paginate @objects, :params => { :pagination => nil } %>
     #   <%= ajax_pagination_loadzone do %>
@@ -122,6 +138,92 @@ module AjaxPagination
         yield
       end
     end
+
+    # modifies the html options, so that it calls AJAX Pagination. This method adds the appropriate parameters to make an AJAX call via
+    # AJAX Pagination, using jquery-ujs.
+    #
+    # More specifically, it ensures the following attributes are defined :remote => true, "data-type" => 'html', :pagination => ?.
+    # The pagination attribute must be defined, or else it defaults to the empty string "".
+    # This link always sets data-remote to true - setting to false is not allowed, since AJAX Pagination would not be triggered.
+    #
+    # Below is an alternative way to create an ajax link instead of ajax_link_to
+    #
+    #   <%= link_to "Name", posts_url, ajax_options :pagination => "page" %>
+    #
+    def ajax_options(html_options = {})
+      html_options["data-pagination".to_sym] = html_options.delete(:pagination) || html_options.delete("data-pagination") || "" # renames the option pagination to data-pagination
+      html_options[:remote] = true
+      html_options["data-type".to_sym] ||= html_options.delete("data-type") || 'html'
+      html_options
+    end
+
+    # Wrapper for link_to, but makes the link trigger an AJAX call through AJAX Pagination.
+    # The arguments passed are in the same order as link_to the advantage of using this helper
+    # is that if the implementation is changed, links using this helper will still work. Internally uses ajax_options
+    #
+    # The example below creates a link "Name", which when clicked, will load posts_url into the section of the page named
+    # "page" using AJAX.
+    #
+    #   <%= ajax_link_to "Name", posts_url, :pagination => "page" %>
+    #
+    def ajax_link_to(*args, &block)
+      if block_given? # inject new html_options argument and call link_to
+        html_options = args[1] || {}
+        args[1] = ajax_options html_options
+        link_to(*args,&block)
+      else
+        html_options = args[2] || {}
+        args[2] = ajax_options html_options
+        link_to(*args)
+      end
+    end
+
+    # Wrapper for form_tag, following are equivalent:
+    #
+    #   <%= ajax_form_tag posts_url, :method => "post", :class => "myclass", :pagination => "page" do %>
+    #     ...
+    #   <% end %>
+    #
+    #   <%= form_tag posts_url, ajax_options :method => "post", :class => "myclass", :pagination => "page" do %>
+    #     ...
+    #   <% end %>
+    #
+    def ajax_form_tag(url_for_options = {}, options = {}, &block)
+      options = ajax_options(options)
+      if block_given?
+        form_tag(url_for_options,options, &block)
+      else
+        form_tag(url_for_options,options)
+      end
+    end
+
+    # Wrapper for form_for. The following are equivalent
+    #
+    #   <%= ajax_form_for @post, :method => "post", :html => {:class => "myclass", :pagination => "menu"} do %>
+    #     ...
+    #   <% end %>
+    #
+    #   <%= form_for @post, :method => "post", :html => ajax_options({:class => "myclass", :pagination => "menu"}) do %>
+    #     ...
+    #   <% end %>
+    #
+    # Please be aware that in the second alternative, you should never set :remote => false manually, eg:
+    #
+    #   <%= form_tag @post, :remote => false, :html => ajax_options(:pagination => "menu") do %><!-- Never Do This!!! -->
+    #
+    # This will prevent AJAX Pagination from being called.
+    #
+    # If you are using Formtastic or Simple Form gems, you can use the second method to add AJAX Pagination functionality
+    # at the same time. This form_for helper is only a convenience method (shorthand)
+    #
+    def ajax_form_for(record, options = {}, &block)
+      raise ArgumentError, "Missing block" unless block_given?
+      options[:html] ||= {}
+      options[:html] = ajax_options options[:html]
+      options.delete(:remote) # html sub-hash already has remote set true
+      form_for(record,options,&block)
+    end
+
   end
 end
 

data/lib/ajax_pagination/rails.rb

@@ -14,5 +14,13 @@ module AjaxPagination
         AjaxPagination.warnings = Rails.env == 'development' # default setting
       end
     end
+
+    initializer 'ajax_pagination.redirect_filter' do
+      if AjaxPagination.redirect_after_filter == true
+        ActiveSupport.on_load(:action_controller) do
+          after_filter :ajax_pagination_redirect
+        end
+      end
+    end
   end
 end

data/lib/ajax_pagination/version.rb

@@ -1,3 +1,3 @@
 module AjaxPagination
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/assets/javascripts/ajax_pagination.js.erb

@@ -8,8 +8,31 @@
  * Copyright (c) 2012 Ronald Ping Man Chan
  * Distributed under the LGPL license
  */
-if (History && History.enabled) {
-  jQuery(document).ready(function () {
+jQuery(document).ready(function () {
+  function minVersion(version) {
+    var $vrs = window.jQuery.fn.jquery.split('.'),
+        min  = version.split('.');
+    for (var i=0, len=min.length; i<len; i++) {
+      if ($vrs[i]) {
+        min[i] = parseInt(min[i],10);
+        $vrs[i] = parseInt($vrs[i],10);
+        if ($vrs[i] < min[i]) return false;
+        else if ($vrs[i] > min[i]) return true;
+      }
+      else return false;
+    }
+    return true;
+  }
+  <% minjQuery = '1.7' %>
+  <% if AjaxPagination.warnings %>
+    if (!(History && minVersion('<%= minjQuery %>'))) { // dependencies missing
+      var missing = "";
+      if (!History) missing += "\nHistory.js not installed";
+      if (!minVersion('<%= minjQuery %>')) missing += "\njQuery version <%= minjQuery %>+ not installed. Currently installed: jQuery " + window.jQuery.fn.jquery;
+      alert("AJAX Pagination warning:" + missing);
+    }
+  <% end %>
+  if (History && History.enabled && minVersion('<%= minjQuery %>')) {
     (function( $ ) {
       var pagination_loader_state = new Array(); // the page we are waiting for
       var pagination_url = location.href; // url we came from, so we can see transitions of the url
@@ -23,7 +46,8 @@ if (History && History.enabled) {
         var height = paginated_content.height();
         // setup loading look
         var img = document.createElement("IMG");
-        img.src = "<%= asset_path AjaxPagination.loading_image %>";
+        if (paginated_section.data("pagination") !== undefined && paginated_section.data("pagination").image !== undefined) img.src = paginated_section.data("pagination").image;
+        else img.src = "<%= asset_path AjaxPagination.loading_image %>";
         var margin = Math.round(height>400?100:(height/4));
         $(img).css({'margin': margin + 'px', 'max-height': (3*height/4) + 'px'}).addClass('ajaxloader');
         var div = document.createElement("DIV");
@@ -33,35 +57,76 @@ if (History && History.enabled) {
         paginated_content.append(div);
 
         // scroll to top of paginated_section if it is not visible
-        if ($('body').scrollTop() > paginated_section.offset().top) {
-          $('body').scrollTop(paginated_section.offset().top);
+        if ($(document).scrollTop() > paginated_section.offset().top - <%= AjaxPagination.scroll_margin %>) {
+          $(document).scrollTop(paginated_section.offset().top - <%= AjaxPagination.scroll_margin %>);
         }
       }
-      function swapPage(pagination_name,requesturl) { // swaps the page at pagination_name to that from requesturl
+      // when this function is used beforeSend of an AJAX request, will use the resulting content in a section of the page
+      // this event handler has the same arguments as for jquery and jquery-ujs, except it also takes the name of the section to put the content into as first argument
+      // adapter functions will be used to reconcile the differences in arguments, this is required because jquery and jquery-ujs has different ways to get the pagination_name argument
+      function beforeSendHandler(pagination_name,jqXHR,settings) {
+        var id = "#" + pagination_name + "_paginated_section"; // element id we are looking for
+        var requesturl = settings.url;
+        if ($(id).length != 1) { // something wrong, cannot find unique section to load page into
+          <% if AjaxPagination.warnings %>
+            alert("AJAX Pagination warning:\nExpected one pagination section called " + pagination_name + ", found " + $("#" + pagination_name + "_paginated_section").length);
+          <% end %>
+          return false; // continue AJAX normally
+        }
         display_pagination_loader(pagination_name);
-        pagination_loader_state[pagination_name] = requesturl; // remember which page number we are waiting for
-        //$.ajax(requesturl,{dataType:'script',cache:true});
+        // register callbacks for other events
+        jqXHR.done(function(data, textStatus, jqXHR) {
+          if (requesturl != pagination_loader_state[pagination_name]) return; // ignore stale content
+          if (jqXHR.status == 200 && jqXHR.getResponseHeader('Location') !== null) { // special AJAX redirect
+            var redirecturl = jqXHR.getResponseHeader('Location');
+            swapPage(pagination_name,redirecturl);
+            pagination_url = redirecturl;
+            History.replaceState(null,document.title,redirecturl);
+            return;
+          }
+          // find matching element id in data, after removing script tags
+          var page = $("<div>").append(data.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,""));
+          var content = page.find(id);
+          if (content.length>0) {
+            $(id).html(content.html());
+            <% if AjaxPagination.warnings %>
+              alert("AJAX Pagination warning:\nExtra content returned by AJAX request ignored. Only a portion of the page content returned by the server was required. To fix this, explicitly call ajax_pagination for :pagination => \"" + pagination_name + "\" to render only the partial view required. This warning can be turned off in the ajax_pagination initializer file.");
+            <% end %>
+          }
+          else { // otherwise use all the content, including any scripts - we consider scripts specifically returned in the partial probably should be re-run
+            page = $("<div>").append(data);
+            content = page.find("body");
+            if (content.length>0) $(id).html(content.html()); // if it has a body tag, only include its contents (for full html structure), leaving out <head> etc sections.
+            else $(id).html(page.html()); // otherwise include the whole html snippet
+          }
+          // if page contains a title, use it
+          content = page.find("title");
+          if (content.length>0) History.replaceState(null,content.html(),location.href);
+          delete pagination_loader_state[pagination_name]; // not waiting for page anymore
+        });
+        jqXHR.fail(function(jqXHR, textStatus, errorThrown) {
+          if (requesturl != pagination_loader_state[pagination_name]) return; // ignore stale content
+          $(id).html(jqXHR.responseText);
+          delete pagination_loader_state[pagination_name]; // not waiting for page anymore
+        });
+        return true;
+      }
+      function swapPage(pagination_name,requesturl) { // swaps the page at pagination_name to that from requesturl (used by History.popState, therefore no remote link has been clicked)
+        // send our own ajax request, and tie it into the beforeSendHandler used for jquery-ujs as well
         $.ajax({url: requesturl, data: {pagination:pagination_name},
           dataType: 'html',
-          success: function(data) {
-            var id = "#" + pagination_name + "_paginated_section"; // element id we are looking for
-            // find matching element id in data, after removing script tags
-            var content = $("<div>").append(data.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,"")).find(id);
-            if (content.length>0) {
-              $(id).html(content.html());
-              <% if AjaxPagination.warnings %>
-                alert("AJAX Pagination warning:\nExtra content returned by AJAX request ignored. Only a portion of the page content returned by the server was required. To fix this, explicitly call ajax_pagination for :pagination => \"" + pagination_name + "\" to render only the partial view required. This warning can be turned off in the ajax_pagination initializer file.");
-              <% end %>
-            }
-            else $(id).html(data); // otherwise use all the content
-            delete pagination_loader_state[pagination_name]; // not waiting for page anymore
-          },
-          error: function(jqXHR, textStatus, errorThrown) {
-            $(id).html(jqXHR.responseText);
+          beforeSend: function (jqXHR,settings) {
+            var result = beforeSendHandler(pagination_name,jqXHR,settings);
+            pagination_loader_state[pagination_name] = settings.url; // remember which page number we are waiting for
+            return result;
           }
         });
       }
-      $('body').on("click", ".pagination a, .ajaxpagination a", function() {
+      // these special containers are for convenience only, to apply the required data-remote, data-pagination attributes to all links inside
+      $(document).on("click", ".pagination a, .ajaxpagination a, a.ajaxpagination", function(e) {
+        // ignore if already selected by jquery-ujs
+        if ($(this).filter($.rails.linkClickSelector).length>0) return true; // continue with jquery-ujs - this behaviour is necessary because we do not know if the jquery-ujs handler executes before or after this handler
+        // find out what data-pagination should be set to
         var pagination_container = $(this).closest(".pagination, .ajaxpagination"); // container of links (use to check for data-pagination first)
         var pagination_name = pagination_container.data('pagination');
         if (pagination_name === undefined) {
@@ -74,18 +139,45 @@ if (History && History.enabled) {
           }
           pagination_name = pagination_name[1];
         }
-        if ($("#" + pagination_name + "_paginated_section").length != 1) { // something wrong, cannot find unique section to load page into
-          <% if AjaxPagination.warnings %>
-            alert("AJAX Pagination warning:\nExpected one pagination section called " + pagination_name + ", found " + $("#" + pagination_name + "_paginated_section").length);
-          <% end %>
-          return true; // follow link normally
+        
+        // set data-remote, data-pagination
+        $(this).attr({'data-remote':'true'}); // needs to be set so that the jquery-ujs selectors work
+        $(this).data({'remote':'true','pagination':pagination_name}); // needs to be set because attributes only read into jquery's data memory once
+        if ($(this).data('type') === undefined) { // to be moved to ajax:before filter when https://github.com/rails/jquery-ujs/pull/241 is successful, and jquery-rails minimum version updated
+          $(this).data('type','html'); // AJAX Pagination requests return html be default
         }
-        //var requesturl = $.param.querystring(this.href,{pagination:pagination_name}); // by default, adds ?pagination=page
-        swapPage(pagination_name,this.href);
-        pagination_url = this.href;
-        History.pushState(null,document.title,this.href);
+        // stop this event from having further effect (because we do not know if jquery-ujs's event handler executed before or after us)
+        e.preventDefault();
+        e.stopImmediatePropagation();
+        // click element again to dispatch the event all over again - thus ensuring it is handled by jquery-ujs
+        $(this).click();
         return false;
       });
+      $(document).on("ajax:before","a, " + $.rails.inputChangeSelector, function() {
+        var pagination_name = $(this).data('pagination');
+        if (pagination_name === undefined) return true; // this is not an AJAX Pagination AJAX request
+        $(this).data('params',$.extend($(this).data('params'),{'pagination':pagination_name})); // add data-pagination to the params data
+        return true;
+      });
+      $(document).on("ajax:before","form", function() {
+        // alter action to include pagination parameter in the GET part of the action url
+        $(this).attr('action',$.param.querystring($(this).attr('action'),{pagination:$(this).data('pagination')}));
+      });
+      $(document).on("ajax:beforeSend","a, form, " + $.rails.inputChangeSelector, function (e,jqXHR,settings) {
+        var pagination_name = $(this).data('pagination');
+        if (pagination_name === undefined) return true; // this is not an AJAX Pagination AJAX request
+        if (beforeSendHandler(pagination_name,jqXHR,settings)) {
+          var data = $("#" + pagination_name + "_paginated_section").data("pagination");
+          if (data === undefined || data.history === undefined || data.history) {
+            var data = $.deparam.querystring($.url(settings.url).attr('query'));
+            delete data['pagination'];
+            pagination_url = $.param.querystring(settings.url,data,2);
+            History.pushState(null,document.title,pagination_url);
+          }
+          pagination_loader_state[pagination_name] = settings.url;
+        }
+        return true;
+      });
 
       History.Adapter.bind(window,'popstate',function(){ // popstate, but can work with hash changes as well
         var from = pagination_url, to = location.href; // from what state to what other state
@@ -95,12 +187,12 @@ if (History && History.enabled) {
           if (pagination_name == null) return; // pagination not set up properly
 
           // if data-pagination is not defined, the use default reload test
-          if ($(this).data('pagination') === undefined) {
+          if ($(this).data('pagination') === undefined || $(this).data('pagination').reload === undefined) {
             // if ?pagination_name=ABC, where ABC is the same for both urls, then don't need to reload
             if ($.deparam.querystring(from)[pagination_name] === $.deparam.querystring(to)[pagination_name]) return;
           }
           else { // otherwise parse json and perform tests
-            var reload = $(this).data('pagination');
+            var reload = $(this).data('pagination').reload;
             if (!(reload instanceof Array)) reload = new Array(reload);
             var changed = false;
             for (i=0;i<reload.length;i++) {
@@ -110,8 +202,8 @@ if (History && History.enabled) {
               if (reload[i].urlregex !== undefined) {
                 var fstr = from, tstr = to;
                 if (reload[i].urlpart !== undefined) {
-                  fstr = $.url(from).attr(reload[i].urlpart);
-                  tstr = $.url(to).attr(reload[i].urlpart);
+                  fstr = $.url(from,true).attr(reload[i].urlpart);
+                  tstr = $.url(to,true).attr(reload[i].urlpart);
                   if (typeof(fstr)!="string" || typeof(tstr)!="string") continue; // skip
                 }
                 var index = 0;
@@ -126,8 +218,7 @@ if (History && History.enabled) {
             }
             if (!changed) return; // otherwise it has changed, and we must reload
           }
-          var requesturl = $.param.querystring(location.href,{pagination:pagination_name}); // by default, adds ?pagination=page
-          swapPage(pagination_name,requesturl);
+          swapPage(pagination_name,location.href);
         });
 
         pagination_url = location.href; // update url (new url recognised)
@@ -135,6 +226,6 @@ if (History && History.enabled) {
 
       History.Adapter.trigger(window,"popstate"); // update stuff on page load
     })( jQuery );
-  });
-}
+  }
+});
 

data/lib/generators/templates/ajax_pagination.rb

@@ -9,4 +9,18 @@ AjaxPagination.config do |config|
   # config.warnings = true
   # or to turn off in all environments
   # config.warnings = false
+
+  # Intercepts 302 redirects, if the request is an AJAX call with a ?pagination= parameter in the GET url
+  # This is used because browsers transparently follow 302 redirects, without the AJAX javascript code being aware
+  # that a redirection has taken place. The response is changed into a Status 200 OK, with an extra Location: header
+  # The javascript code can then manually follow the redirect, and perform the necessary cleanup tasks (change the url
+  # in the address bar). The default is on (true), use the following line to disable it if desired. If disabled, it can
+  # be re-enabled in specific controllers by adding after_filter :ajax_pagination_redirect to the class.
+  # config.redirect_after_filter = true
+
+  # when changing pages, AJAX Pagination scrolls to ensure the page sees the top of the changing section, plus an additional margin in pixels
+  # The default margin is 20 pixels, as set by the line below
+  # config.scroll_margin = 20
+  # To disable auto-scrolling, uncomment the line below
+  # config.scroll_margin = '-Infinity'
 end

data/spec/ajax_pagination/controller_additions_spec.rb

@@ -5,7 +5,7 @@ describe AjaxPagination::ControllerAdditions do
     @controller.stub!(:params).and_return({:pagination => name, :controller => "dummycontroller"})
   end
   def stub_request_format_html(bool)
-    @controller.stub!(:request).and_return(stub(:format => stub(:html? => bool)))
+    @controller.stub!(:request).and_return(stub({:format => stub(:html? => bool), :GET => {} }))
   end
   def stub_lookup_context(result)
     @controller.stub!(:lookup_context).and_return(stub(:find_all => result))

data/spec/ajax_pagination/integration/ajaxpaginate_spec.rb

@@ -2,63 +2,148 @@ require 'spec_helper'
 
 describe 'paginating with javascript on', :js => true do
   it 'displays a loading image' do
+    # following 3 lines to warm up loading image
+    visit("http://localhost:#{SERVERPORT}") # goes to welcome page
+    click_link 'About'
+    sleep(2)
+
     visit("http://localhost:#{SERVERPORT}") # goes to welcome page
     page.should have_no_selector('.ajaxloader')
+    sleep(1)
     click_link 'About'
     page.should have_selector('.ajaxloader')
-    sleep(0.5)
+    sleep(1)
     page.should have_no_selector('.ajaxloader')
     click_link 'Readme'
     page.should have_selector('.ajaxloader')
-    sleep(0.5)
+    sleep(1)
     page.should have_no_selector('.ajaxloader')
   end
   it 'displays a loading image with nested and multiple paginated sections' do
     visit("http://localhost:#{SERVERPORT}/changelog")
-    find('#page_paginated_section').find('.next_page').click
+    find('#_paginated_section').find('.next_page').click
     page.should have_selector('.ajaxloader')
-    sleep(0.5)
+    sleep(1)
     page.should have_no_selector('.ajaxloader')
     find('#signin').click
     visit("http://localhost:#{SERVERPORT}/posts")
     sleep(2)
     find('#page_paginated_section').find('.next_page').click
     page.should have_selector('.ajaxloader')
-    sleep(0.5)
+    sleep(1)
     page.should have_no_selector('.ajaxloader')
     find('#upcomingpage_paginated_section').find('.next_page').click
     page.should have_selector('.ajaxloader')
-    sleep(0.5)
+    sleep(1)
     page.should have_no_selector('.ajaxloader')
   end
   it 'shows the configured loading image' do
     visit("http://localhost:#{SERVERPORT}/changelog")
-    find('#page_paginated_section').find('.next_page').click
+    find('#_paginated_section').find('.next_page').click
     page.should have_xpath("//img[@class='ajaxloader' and @src = '/assets/myajax-loader.gif']")
+    sleep(1)
+    visit("http://localhost:#{SERVERPORT}/posts")
+    find('#_paginated_section').find('.next_page').click
+    page.should have_xpath("//img[@class='ajaxloader' and @src = '/assets/ajax-loader.gif']")
   end
   it 'works with browser back and forward buttons' do
     visit("http://localhost:#{SERVERPORT}/changelog")
-    find('#page_paginated_section').find('.next_page').click
-    sleep(0.5)
+    find('#_paginated_section').find('.next_page').click
+    sleep(1)
     click_link 'About'
-    sleep(0.5)
+    sleep(1)
     click_link 'Readme'
     sleep(2)
     page.should have_no_selector('.ajaxloader')
     page.should have_selector('#readmepagetitle')
     page.evaluate_script('window.history.back();') # back to About
     page.should have_selector('.ajaxloader')
-    sleep(0.5)
+    sleep(1)
     page.should have_no_selector('.ajaxloader')
     page.should have_selector('#aboutpagetitle')
     page.evaluate_script('window.history.forward();') # forward to readme
-    sleep(0.5)
+    sleep(1)
     page.should have_selector('#readmepagetitle')
     page.evaluate_script('window.history.go(-2);') # back to changelog page 2
-    sleep(0.5)
+    sleep(1)
     page.should have_no_selector('#aboutpagetitle')
     page.evaluate_script('window.history.forward();') # forward to about
-    sleep(0.5)
+    sleep(1)
     page.should have_selector('#aboutpagetitle')
   end
+  it 'displays error pages within div' do
+    visit("http://localhost:#{SERVERPORT}") # goes to welcome page
+    click_link("AJAX Pagination Example Application")
+    sleep(2)
+    page.current_url.should == "http://localhost:#{SERVERPORT}/broken%20link"
+    page.should have_content("AJAX Pagination Example Application")
+    page.should have_content("No route matches")
+  end
+  it 'changes url to match redirection' do
+    visit("http://localhost:#{SERVERPORT}")
+    click_link("Posts")
+    sleep(1)
+    page.should have_content("New Post")
+    myurl = page.current_url # to get the canonical url
+    click_link("New Post")
+    sleep(2)
+    page.should have_content("Access Denied")
+    page.current_url.should == myurl
+  end
+  it 'submits ajax_form_tag form via post' do
+    visit("http://localhost:#{SERVERPORT}/pages/about")
+    count = page.find("#submits").html.to_i
+    click_button("Submit")
+    sleep(1)
+    page.should have_content("#{count+1} submit")
+    page.should have_selector('#aboutpagetitle') # ensures loading was via AJAX Pagination
+  end
+  it 'history does not change if :history => false' do
+    visit("http://localhost:#{SERVERPORT}/pages/about")
+    myurl = page.current_url # to get the canonical url
+    count = page.find("#submits").html.to_i
+    click_button("Submit")
+    sleep(1)
+    page.should have_content("#{count+1} submit")
+    page.current_url.should == myurl # url remains the same (so history has not changed)
+  end
+  it 'submits ajax_form_for form via POST and PUT and DELETE link' do
+    visit("http://localhost:#{SERVERPORT}")
+    find('#signin').click
+    click_link("Posts")
+    sleep(1)
+    page.should have_content("New Post")
+    myurl = page.current_url # to get the canonical url
+    visit("http://localhost:#{SERVERPORT}/posts/new")
+    within("#new_post") do
+      fill_in 'Title', :with => 'very unique title for test'
+      fill_in 'Content', :with => 'my supercontent'
+    end
+    click_button("Create Post");
+    page.should have_selector('.ajaxloader')
+    sleep(2)
+    page.should have_content("Post was successfully created.")
+    page.current_url.should_not == myurl # means we have gotten redirected
+    click_link("Edit");
+    within(".edit_post") do
+      fill_in 'Content', :with => 'my supercontent again'
+    end
+    click_button("Update Post");
+    page.should have_selector('.ajaxloader')
+    sleep(2)
+    page.should have_content("my supercontent again")
+    click_link("Destroy");
+    page.driver.browser.switch_to.alert.accept
+    page.should have_selector('.ajaxloader')
+    sleep(2)
+    page.should have_content("Post destroyed.")
+  end
+  it 'changes title' do
+    visit("http://localhost:#{SERVERPORT}")
+    title = page.evaluate_script("document.title") # because what is between the <title> tags and what is shown in the window title can differ (document.title gets set by javascript)
+    click_link("About");
+    sleep(1)
+    page.should have_selector('#aboutpagetitle') # ensures loading was via AJAX Pagination
+    page.evaluate_script("document.title").should_not == title
+  end
 end

data/spec/ajax_pagination/integration/nojavascript_spec.rb

@@ -15,16 +15,15 @@ describe 'paginating without javascript', :type => :request, :driver => :rack_te
   it 'still paginates nested and multiple paginated sections' do
     visit(changelog_url)
     page.should have_selector('.previous_page.disabled')
-    find('#page_paginated_section').find('.next_page').click
+    find('#_paginated_section').find('.next_page').click
     page.should have_no_selector('.previous_page.disabled')
     find('#signin').click
     visit(posts_url)
-    page.should have_selector('#page_paginated_section .previous_page.disabled')
-    find('#page_paginated_section').find('.next_page').click
-    page.should have_no_selector('#page_paginated_section .previous_page.disabled')
     page.should have_selector('#upcomingpage_paginated_section .previous_page.disabled')
     find('#upcomingpage_paginated_section').find('.next_page').click
     page.should have_no_selector('#upcomingpage_paginated_section .previous_page.disabled')
+    page.should have_selector('#page_paginated_section .previous_page.disabled')
+    find('#page_paginated_section').find('.next_page').click
     page.should have_no_selector('#page_paginated_section .previous_page.disabled')
   end
 end

data/spec/rails_app/app/controllers/application_controller.rb

@@ -1,11 +1,10 @@
 class ApplicationController < ActionController::Base
   protect_from_forgery
   before_filter :slowajaxload
-  ajax_pagination :pagination => 'menu'
-  #ajax_pagination :pagination => 'sdf', :partial => {:template => "pages/readme"}
+  ajax_pagination :pagination => "", :render => { :layout => "ajax" }
   def slowajaxload
     if params[:pagination] && Rails.env == "test"
-      sleep(0.5)
+      sleep(1)
     end
   end
 

data/spec/rails_app/app/controllers/changelog_controller.rb

@@ -7,7 +7,6 @@ class ChangelogController < ApplicationController
     respond_to do |format|
       format.html # index.html.erb
       ajax_pagination(format)
-      ajax_pagination format, :pagination => :menu
     end
   end
 end

data/spec/rails_app/app/controllers/pages_controller.rb

@@ -5,7 +5,7 @@ class PagesController < ApplicationController
     @readme = IO.read(File.expand_path("../../../../../README.md",__FILE__))
     respond_to do |format|
       format.html
-      ajax_pagination format, :pagination => :menu, :render => {:file => "pages/readme"}
+      ajax_pagination format, :pagination => "", :render => {:file => "pages/readme", :layout => "ajax"}
     end
   end
 
@@ -15,7 +15,7 @@ class PagesController < ApplicationController
   def welcome
     respond_to do |format|
       format.html
-      ajax_pagination format, :pagination => :menu
+      ajax_pagination format, :pagination => "", :render => { :layout => "ajax" }
     end
   end
 end

data/spec/rails_app/app/controllers/posts_controller.rb

@@ -9,7 +9,7 @@ class PostsController < ApplicationController
       format.html # index.html.erb
       format.json { render :json => @posts }
       ajax_pagination format, :pagination => :upcomingpage
-      ajax_pagination format, :pagination => :menu
+      ajax_pagination format, :pagination => "", :render => { :layout => "ajax" }
     end
   end
 
@@ -87,7 +87,7 @@ class PostsController < ApplicationController
     @post.destroy
 
     respond_to do |format|
-      format.html { redirect_to posts_url }
+      format.html { redirect_to posts_url, :notice => "Post destroyed." }
       format.json { head :no_content }
     end
   end

data/spec/rails_app/app/controllers/sessions_controller.rb

@@ -8,4 +8,12 @@ class SessionsController < ApplicationController
     session[:admin] = false
     redirect_to root_url, :notice => "Successfully signed out"
   end
+
+  def count
+    session[:count] ||= 0
+    if request.post?
+      session[:count] += 1
+    end
+    render :layout => false
+  end
 end

data/spec/rails_app/app/views/layouts/ajax.html.erb

@@ -0,0 +1,8 @@
+<html>
+<head>
+  <title><%= (params[:controller] + " " + params[:action]).titleize %> - RailsApp</title>
+</head>
+<body>
+  <%= render :template => "layouts/flash" %>
+</body>
+</html>

data/spec/rails_app/app/views/layouts/application.html.erb

@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
-  <title>RailsApp</title>
+  <title><%= (params[:controller] + " " + params[:action]).titleize %> - RailsApp</title>
   <%= stylesheet_link_tag    "application", :media => "all" %>
   <%= javascript_include_tag "application" %>
   <%= csrf_meta_tags %>
@@ -14,8 +14,13 @@
     <%= link_to "Sign in as admin", sessions_signin_url, :id => "signin" %>
   <% end %>
 </div>
-<h1>AJAX Pagination Example Application</h1>
-<div class="ajaxpagination menu" data-pagination="menu">
+<div style="float: right; min-width: 150px;">
+<%= ajax_pagination :pagination => "count", :history => false do %>
+  <%= render :template => "sessions/count" %>
+<% end %>
+</div>
+<h1><%= ajax_link_to "AJAX Pagination Example Application", "broken link", :pagination => "" %><!-- note the broken link is intentional, for testing purposes --></h1>
+<div class="ajaxpagination menu" data-pagination="">
   <ul>
     <li><%= link_to "Home", root_url %></li>
     <li><%= link_to "Posts", posts_url %></li>
@@ -24,14 +29,8 @@
     <li><%= link_to "About", pages_about_url %></li>
   </ul>
 </div>
-<%= ajax_pagination :pagination => "menu", :reload => {:urlpart => "path", :urlregex => "^.*$"}, :loadzone => true do %>
-  <% if flash[:notice] %>
-    <p id="notice"><%= flash[:notice] %></p>
-  <% end %>
-  <% if flash[:alert] %>
-    <p id="alert"><%= flash[:alert] %></p>
-  <% end %>
-  <%= yield %>
+<%= ajax_pagination :pagination => "", :reload => {:urlpart => "path", :urlregex => "^.*$"}, :loadzone => true do %>
+  <%= render :template => "layouts/flash" %>
 <% end %>
 </body>
 </html>

data/spec/rails_app/app/views/layouts/flash.html.erb

@@ -0,0 +1,7 @@
+<% if flash[:notice] %>
+  <p id="notice"><%= flash[:notice] %></p>
+<% end %>
+<% if flash[:alert] %>
+  <p id="alert"><%= flash[:alert] %></p>
+<% end %>
+<%= yield %>

data/spec/rails_app/app/views/posts/_form.html.erb

@@ -1,4 +1,4 @@
-<%= form_for(@post) do |f| %>
+<%= ajax_form_for(@post) do |f| %>
   <% if @post.errors.any? %>
     <div id="error_explanation">
       <h2><%= pluralize(@post.errors.count, "error") %> prohibited this post from being saved:</h2>

data/spec/rails_app/app/views/posts/_page.html.erb

@@ -4,10 +4,10 @@
     <div style="border-bottom: 1px solid black; padding-bottom: 10px;">
       <p><h3><%= post.title %></h3><i>Published on <%= post.published_at.strftime('%d %B %Y') if post.published_at? %></i></p>
       <%= simple_format(post.content) %>
-      <%= link_to 'Show', post %>
+      <%= ajax_link_to 'Show', post, :pagination => "" %>
       <% if session[:admin] %>
-        | <%= link_to 'Edit', edit_post_path(post) %> |
-        <%= link_to 'Destroy', post, :confirm => 'Are you sure?', :method => :delete %>
+        | <%= ajax_link_to 'Edit', edit_post_path(post), :pagination => "" %> |
+        <%= ajax_link_to 'Destroy', post, :confirm => 'Are you sure?', :method => :delete, :pagination => "" %>
       <% end %>
     </div>
   <% end %>

data/spec/rails_app/app/views/posts/index.html.erb

@@ -8,8 +8,8 @@
   <h3>Published</h3>
 <% end %>
 
-<%= ajax_pagination %>
+<%= ajax_pagination :image => "ajax-loader.gif" %>
 
 <br />
 
-<%= link_to 'New Post', new_post_path %>
+<%= ajax_link_to 'New Post', new_post_path %><!-- This link is intentionally unsecured, so non-admins will get a redirection to an "access denied" page -->

data/spec/rails_app/app/views/posts/show.html.erb

@@ -8,6 +8,7 @@
 
 
 <% if session[:admin] %>
-  <%= link_to 'Edit', edit_post_path(@post) %> |
+  <%= ajax_link_to 'Edit', edit_post_path(@post) %> |
+  <%= ajax_link_to 'Destroy', @post, :confirm => 'Are you sure?', :method => :delete, :pagination => "" %> |
 <% end %>
-<%= link_to 'Back', posts_path %>
+<%= ajax_link_to 'Back', posts_path %>

data/spec/rails_app/app/views/sessions/count.html.erb

@@ -0,0 +1,7 @@
+<span id="submits"><%= session[:count].to_i %></span> 
+submit<%= 's' unless session[:count]==1 %> so far.
+<%= ajax_form_tag sessions_count_url, :method => "post", :pagination => "count" do %>
+  <span class="actions">
+    <%= submit_tag "Submit" %>
+  </span>
+<% end %>

data/spec/rails_app/config/routes.rb

@@ -12,6 +12,8 @@ RailsApp::Application.routes.draw do
   namespace :sessions do
     get 'signin'
     get 'signout'
+    get 'count'
+    post 'count'
   end
   # The priority is based upon order of creation:
   # first created -> highest priority.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ajax_pagination
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-23 00:00:00.000000000 Z
+date: 2012-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &17693300 !ruby/object:Gem::Requirement
+  requirement: &5860940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *17693300
+  version_requirements: *5860940
 - !ruby/object:Gem::Dependency
   name: rspec-rails
-  requirement: &17692880 !ruby/object:Gem::Requirement
+  requirement: &5860300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *17692880
+  version_requirements: *5860300
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &17692440 !ruby/object:Gem::Requirement
+  requirement: &5859780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *17692440
+  version_requirements: *5859780
 - !ruby/object:Gem::Dependency
   name: will_paginate
-  requirement: &17691880 !ruby/object:Gem::Requirement
+  requirement: &5859220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *17691880
+  version_requirements: *5859220
 - !ruby/object:Gem::Dependency
   name: capybara
-  requirement: &17691360 !ruby/object:Gem::Requirement
+  requirement: &5858640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *17691360
+  version_requirements: *5858640
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &17690540 !ruby/object:Gem::Requirement
+  requirement: &5857940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +76,10 @@ dependencies:
         version: '3.1'
   type: :runtime
   prerelease: false
-  version_requirements: *17690540
+  version_requirements: *5857940
 - !ruby/object:Gem::Dependency
   name: jquery-rails
-  requirement: &17720620 !ruby/object:Gem::Requirement
+  requirement: &5857180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,10 +87,10 @@ dependencies:
         version: 1.0.17
   type: :runtime
   prerelease: false
-  version_requirements: *17720620
+  version_requirements: *5857180
 - !ruby/object:Gem::Dependency
   name: jquery-historyjs
-  requirement: &17720080 !ruby/object:Gem::Requirement
+  requirement: &5856700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -98,7 +98,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *17720080
+  version_requirements: *5856700
 description: Handles AJAX pagination for you, by hooking up the links you want to
   load content with javascript in designated page containers. Each webpage can have
   multiple page containers, each with a different set of pagination links. The page
@@ -158,7 +158,9 @@ files:
 - spec/rails_app/app/models/post.rb
 - spec/rails_app/app/views/changelog/_page.html.erb
 - spec/rails_app/app/views/changelog/index.html.erb
+- spec/rails_app/app/views/layouts/ajax.html.erb
 - spec/rails_app/app/views/layouts/application.html.erb
+- spec/rails_app/app/views/layouts/flash.html.erb
 - spec/rails_app/app/views/pages/about.html.erb
 - spec/rails_app/app/views/pages/readme.html.erb
 - spec/rails_app/app/views/pages/welcome.html.erb
@@ -169,6 +171,7 @@ files:
 - spec/rails_app/app/views/posts/index.html.erb
 - spec/rails_app/app/views/posts/new.html.erb
 - spec/rails_app/app/views/posts/show.html.erb
+- spec/rails_app/app/views/sessions/count.html.erb
 - spec/rails_app/config.ru
 - spec/rails_app/config/application.rb
 - spec/rails_app/config/boot.rb
@@ -215,12 +218,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -3757162407362940278
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -3757162407362940278
 requirements: []
 rubyforge_project: ajax_pagination
 rubygems_version: 1.8.15