ajax_pagination 0.1.0 → 0.2.0

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## 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 => "" }.**
+
+* Fix jquery_rails dependency, requires jQuery 1.7+
+* rename :partial option to :render in controller_additions methods (all instance and class methods added to ActionController). This is because it now has behaviour like the ActionController render function rather than the ActionView render function
+* change AJAX requests from js to html format. The motivation is to lower barrier to entry, getting AJAX to work. Now, no actual ajax_pagination instance method need be called in the controllers. It is less efficient, and normally not recommended, but not calling it will result in the default template (full page including application layout) to be returned in the AJAX call. AJAX Pagination can then pick out the paginated section required (throwing away everything else).
+* removed all publicly accessible javascript function, there was 1 accessible function for the AJAX result, but it has been removed in favour of the jQuery callback
+* added class method to ActionController which can add AJAX Pagination behaviour to the default_render method. This can be called at the ApplicationController level or for a specific controller. However, this is probably most useful at the application level for AJAX menu navigation (so that ajax_pagination does not need to be called in each controller/action)
+* Warnings added when AJAX Pagination cannot complete AJAX action, or when the setup is suboptimal. This is on only in development mode by default (see gem initializer). These warnings appear as alerts, and are displayed by the javascript code.
+* Initializer generator added, with configuration for an alternative loading image, and warnings setting.
+* renamed data-reload to data-pagination. The new attribute name is already used, but in different circumstances. Note this attribute is only set internally, so usage has not changed. This change should minimise the footprint of AJAX Pagination.
+* updated readme
+
 ## v0.1.0
 * Added functional tests for controller and helper additions.
 * Mocked up a rails application using ajax_pagination, at spec/rails_app/. You can run this example application using:

data/README.md

@@ -37,7 +37,15 @@ AJAX Pagination depends on jquery-rails and jquery-historyjs, so if their javasc
 //= require history
 ```
 
-## Getting started
+## 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)
+
+and much [more](https://github.com/ronalchn/ajax_pagination/wiki/Home).
+
+## Usage
 
 The pagination needs a name (in case you have multiple sets of AJAX pagination on the same webpage). By default, the name is "page". If you only intend to use a single set of pagination links, then leave it as "page". The name is used to distinguish different sets of pagination links, and is also used as a default for other functionaility.
 
@@ -62,7 +70,7 @@ If the pagination name is not "page", pass the new pagination name in.
 If the partial is not named the same, pass it the new name as an option:
 
 ```erb
-<%= ajax_pagination :partial => "mypartial" %>
+<%= ajax_pagination :render => "mypartial" %>
 ```
 
 This will cause it to display content in the _mypartial.* view.
@@ -102,11 +110,17 @@ If the links are outside the partial, you will need to also let AJAX Pagination
 <% end %>
 ```
 
-Incidentally, this example also presents an alternative to passing in a :partial option to <tt>ajax_pagination</tt>. Instead, you can pass it a block, in which case you can call the render helper yourself, or any other function (in this case, yield). If a block is passed, any :partial option is ignored.
+Incidentally, this example also presents an alternative to passing in a :render option to <tt>ajax_pagination</tt>. Instead, you can pass it a block, in which case you can call the render helper yourself, or any other function (in this case, yield). If a block is passed, any :render option is ignored.
 
 ### Controller responder
 
-However, the controller needs to be told how to respond. Add a call to <tt>ajax_pagination(format)</tt> in the controller action, which will return javascript containing the partial.
+However, the controller needs to be told how to respond. If we do not indicate the response, it will render the whole html page as usual. This will still work (and only display the new content required), but it will send all the page content. By default, when this happens in development, an alert will pop up warning that this is not the best solution. AJAX Pagination works around this by detecting that you want to load new content into a section called "page" for example, but the new content actually contains a section called "page". Therefore, it replaces the old content with only the content of the response inside the section "page".
+
+This behaviour makes it easy to get AJAX Pagination working. And if you are not worried about efficiency (sending all the page content all the time), or if you are doing this for page caching purposes, you can leave it as is. To turn off the warning in development mode, simply generate an initializer, and set ```ruby
+config.warnings = false
+```.
+
+To only send the data that is required (not including the page layout etc.), add a call to <tt>ajax_pagination(format)</tt> in the controller action.
 
 ```ruby
 respond_to do |format|
@@ -115,13 +129,57 @@ respond_to do |format|
 end
 ```
 
-If either the pagination name or the partial filename is not the default, you will need to pass these in as options.
+If either the pagination name or the partial filename is not the default (a partial named whatever :pagination is, "_page" in this case), you will need to pass these in as options.
+
+```ruby
+ajax_pagination format, :pagination => "page", :render => "mytemplate"
+```
+
+This will render controller/mytemplate. If you want a partial to be rendered, use:
 
 ```ruby
-ajax_pagination format, :pagination => "page", :partial => "mypartial"
+ajax_pagination format, :pagination => "page", :render => {:partial => "mytemplate"}
 ```
 
-The pagination should now work.
+In both cases, the layout is off by default. You can pass in a layout to use in the render by the usual means.
+
+The pagination should now be more efficient.
+
+### Default controller responder
+
+Although it is fine if used for a single action, eg. with will_paginate, individually adding a respond_to line for every controller and action might take a while, if used for site navigation, or navigating between the different actions of a single controller.
+
+There is also a class method defined for ActionController, also named ajax_pagination. If we are using it for site navigation, and the pagination name is "menu", then we can simply call:
+
+```ruby
+class ApplicationController < ActionController:Base
+  ajax_pagination :pagination => "menu"
+end
+```
+
+We can, as with the instance method, also pass in a ```ruby
+:render => { :template => "myview", :layout => "mylayout" }
+``` option. However, in this case, it is actually designed to be used without specifying the view template displayed. The reason is that when it is not defined, the default behaviour is normally what you want. Suppose you accessed a page at the url /controller/action?pagination=menu. The pagination=menu query argument indicates that this is a special AJAX request. If pagination is not defined exactly as "menu" in this example, the rendering does not trigger.
+
+AJAX Pagination first tries to render "controller/_menu", :layout => false, if it exists. If it does not, then it will render "controller/action", :layout => false.
+
+Therefore, when used for site navigation, it will by default, render the same page it would otherwise have rendered, only without the layout. Sometimes, we have parts of the page we want to render again (and is wrapped by the ajax_pagination container which identifies the section of the page which is reloaded), but exists in the layout. To deal with this case, we can set the layout to a special layout. This is used if, for example, we have flash notices or alerts we want to be removed, or displayed as appropriate for each AJAX call.
+
+In this case, we create a layout in layouts/flash_layout.html.erb for example, which renders the flash notices. Then, we can pass the layout in as follows:
+
+```ruby
+class ApplicationController < ActionController:Base
+  ajax_pagination :pagination => "menu", :render => { :layout => "flash_layout" }
+end
+```
+
+Notice that no template file is specified. By not specifying the view template file, the controller/action view will be rendered.
+
+If we want to navigate within a controller, we can use this in the specific controller instead of the ApplicationController.
+
+Please note that the class method only specifies the default behaviour, by defining default_render (but it only triggers on the AJAX calls, otherwise it calls the original default_render function to handle the rendering). This default can be overrided by calling the instance method within an action, allowing you to use this for special cases (controllers or actions).
+
+Because the default_render method is used, if you subsequently define default_render, you may clobber the behaviour defined by AJAX Pagination. To deal with this, make sure that the call to the ajax_pagination class method is after any other definition. AJAX Pagination will not clobber any default_render method already defined. Requests which are not AJAX calls will be passed on to the original default_render method.
 
 ### Loading visualization
 
@@ -138,7 +196,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. (TODO: add default loader image, and make the location changeable)
+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 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:
 
@@ -181,6 +239,12 @@ Instead of passing in the Array/Hash Ruby object, a string in json form is accep
 ```erb
 <%= ajax_pagination :reload => '[{"urlregex":"page=([0-9]+)","regexindex":1},{"query":"page"}]' %>
 ```
+
+### Initializer
+You can configure AJAX Pagination in the initializer. Run ```
+rails generate ajax_pagination:install
+``` to get the initializer file.
+
 ## Example Application
 This gem contains an example application (actually, it is there also for testing purposes), however it is nevertheless a good example.
 

data/ajax_pagination.gemspec

@@ -26,7 +26,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency "capybara"
 
   s.add_runtime_dependency "rails", '>= 3.1'
-  s.add_runtime_dependency "jquery-rails", '>= 1.0'
+  s.add_runtime_dependency "jquery-rails", '>= 1.0.17' # require jQuery 1.7+
   s.add_runtime_dependency "jquery-historyjs"
 
 end

data/lib/ajax_pagination.rb

@@ -4,4 +4,16 @@ require "ajax_pagination/helper_additions"
 require "ajax_pagination/rails"
 
 module AjaxPagination
+  # default loading image to use
+  mattr_accessor :loading_image
+  @@loading_image = "ajax-loader.gif"
+
+  # whether javascript warnings are on, these present themselves as alerts
+  mattr_accessor :warnings
+  @@warnings = nil # if nil, uses default, which is true only in development mode
+
+  # run rails generate ajax_pagination:install to create a default initializer with configuration values
+  def self.config
+    yield self
+  end
 end

data/lib/ajax_pagination/controller_additions.rb

@@ -1,7 +1,44 @@
 module AjaxPagination
   # This module is automatically added to all controllers
   module ControllerAdditions
-    # Registers a javascript format when params [:pagination] matches options [:pagination] ( = "page" by default).
+    module ClassMethods
+      # Adds default render behaviour for requests with a pagination parameter matching a certain name. By default, this name is the empty string. However, it can be changed.
+      # Options:
+      # [:+pagination+]
+      #   The pagination name which should be matched to invoke AJAX Pagination response. Defaults to the empty string "". This is unlike other
+      #   methods which default to "page". However, this is a better default in this case because this affects more than one controller/action.
+      #
+      # [:+render+]
+      #   Overrides default render behaviour for AJAX Pagination, which is to render the partial with name matching the pagination option,
+      #   or if it does not exist, renders the default template
+      #
+      def ajax_pagination(options = {});
+        # instead of defining default render normally, we save an unbound reference to original function in case it was already defined, since we want to retain the original behaviour, and add to it (if the method is redefined after, this new behaviour is lost, but at least we don't remove others' behaviour - note that this also allows multiple invocations of this with different parameters)
+        default_render = self.instance_method(:default_render) # get a reference to original method
+        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
+            unless view
+              if lookup_context.find_all("#{params[:controller]}/_#{params[:pagination]}").any?
+                view = { :partial => params[:pagination] } # render partial, layout is off
+              else
+                view = { :layout => false } # render default view, but turn off layout
+              end
+            end
+            respond_to do |format|
+              ajax_pagination format, :pagination => pagination, :render => view
+            end
+          else # otherwise do what would have been done
+            default_render.bind(self).call(*args) # call original method of the same name
+          end
+        end
+      end
+    end
+    def self.included(base)
+      base.extend ClassMethods
+    end
+    # Registers an ajax response in html format when params [:pagination] matches options [:pagination] ( = "page" by default).
     # AJAX Pagination uses this response to render only the content which has changed. When this format is triggered,
     # a partial is passed back, and sent to AJAX Pagination as a function argument in javascript.
     #
@@ -22,24 +59,31 @@ module AjaxPagination
     #   Changes the pagination name triggering this response. Triggered when params [:pagination] == options [:pagination].
     #   Defaults to "page"
     #
-    # [:+partial+]
-    #   Changes the partial that is returned by this response. Defaults to options [:pagination]. The value can be any object,
-    #   and is rendered directly. Therefore, it need not be a string (which renders _page.html.erb for example). Often,
-    #   the view to be rendered is not a partial. This is the case if AJAX Pagination is used for menu navigation links.
-    #   In this case, each controller action will need to be able to handle AJAX calls and render the full view. To do this,
-    #   pass a hash, specifying a file as shown below. That way, a view file without a leading underscore is rendered.
+    # [:+render+]
+    #   Changes the default template/partial that is rendered by this response. The value can be any object,
+    #   and is rendered directly. The render behaviour is the same as the render method in controllers. If this option is not used,
+    #   then the default is a partial of the same name as :pagination, if it exists, otherwise, if it does not,
+    #   the default template is rendered (ie. the :controller/:action.:format view file). By default, no layout is used
+    #   to render the template/partial. It can be set by passing in a layout key.
     #
     #     def welcome
     #       respond_to do |format|
     #         format.html
-    #         ajax_pagination format, :pagination => :menu, :partial => {:file => "pages/welcome"}
+    #         ajax_pagination format, :pagination => :menu, :render => {:file => "pages/welcome"}
     #       end
     #     end
     #
     def ajax_pagination(format,options = {})
       if params[:pagination] == (options[:pagination] || 'page').to_s
-        partial = options[:partial] || params[:pagination]
-        format.js { render :inline => "jQuery.ajaxPagination(\"#{params[:pagination]}\",\"#{request.url}\",\"<%= raw escape_javascript(render(partial)) %>\");", :locals => { :partial => partial } }
+        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
+        else # render usual view
+          view = {}
+        end
+        view = { :layout => false }.merge(view); # set default of no layout rendered
+        format.html { render view }
         return true
       else
         return false
@@ -48,7 +92,7 @@ module AjaxPagination
 
     # Tests whether an AJAX Pagination partial might be displayed in the view. If the response is not directly controlled by
     # AJAX Pagination, it will return true, because the partial might be displayed. The response is handled by AJAX Pagination
-    # if the format is js (javascript), and the params [:pagination] parameter is set. If it is set, then it will return whether
+    # if the format is html, and the params [:pagination] parameter is set. If it is set, then it will return whether
     # params [:pagination] == pagination (the name of the pagination set, which defaults to page).
     #
     # This method is a convenience function so that the controller does not need to perform heavy computation which might only
@@ -81,13 +125,8 @@ 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.js?) || (params[:pagination].nil?) || (params[:pagination] == pagination.to_s)
+      (!request.format.html?) || (params[:pagination].nil?) || (params[:pagination] == pagination.to_s)
     end
   end
 end
-if defined? ActionController
-  ActionController::Base.class_eval do
-    include AjaxPagination::ControllerAdditions
-  end
-end
 

data/lib/ajax_pagination/helper_additions.rb

@@ -41,10 +41,11 @@ module AjaxPagination
     #   wrapping div tag. The name passed here should be the same as the pagination name used in the controller
     #   respond_to block. Defaults to "page".
     #
-    # [:+partial+]
+    # [:+render+]
     #   Changes the partial which is rendered. Defaults to +options [:pagination]+. The partial should generally
     #   be the same as that given in the controller respond_to block, unless you are doing something strange. If a
-    #   block is passed to the function, this option is ignored.
+    #   block is passed to the function, this option is ignored. You can also pass options instead to render other
+    #   files, in which case, the behaviour is the same as the render method in views.
     #
     # [:+reload+]
     #   Used to detect whether the partial needs reloading, based on how the url changes. When pagination links are
@@ -78,34 +79,24 @@ module AjaxPagination
     #
     def ajax_pagination(options = {})
       pagination = options[:pagination] || 'page' # by default the name of the pagination is 'page'
-      partial = options[:partial] || pagination # default partial rendered is the name of the pagination
+      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-reload"] = reload
+        divoptions["data-pagination"] = reload
       when "Hash", "Array"
-        divoptions["data-reload"] = reload.to_json
+        divoptions["data-pagination"] = reload.to_json
       end
       if options[:loadzone]
         divoptions[:class] = "paginated_section paginated_content"
         divoptions[:style] = "position: relative;"
       end
       content_tag :div, divoptions do
-        if options[:loadzone]
-          content_tag :div do # for changing the opacity as whole section is a loadzone
-            if block_given?
-              yield
-            else
-              render partial
-            end
-          end
+        if block_given?
+          yield
         else
-          if block_given?
-            yield
-          else
-            render partial
-          end
+          render partial
         end
       end
     end
@@ -128,16 +119,9 @@ module AjaxPagination
     #
     def ajax_pagination_loadzone()
       content_tag :div, :class => "paginated_content", :style => "position: relative;" do
-        content_tag :div do # for changing the opacity
-          yield
-        end
+        yield
       end
     end
   end
 end
-if defined? ActionView
-  ActionView::Base.class_eval do
-    include AjaxPagination::HelperAdditions
-  end
-end
 

data/lib/ajax_pagination/rails.rb

@@ -1,4 +1,18 @@
 module AjaxPagination
   class Engine < ::Rails::Engine
+    initializer 'ajax_pagination.actionpack_additions' do
+      ActiveSupport.on_load(:action_controller) do
+        include AjaxPagination::ControllerAdditions
+      end
+      ActiveSupport.on_load(:action_view) do
+        include AjaxPagination::HelperAdditions
+      end
+    end
+
+    initializer 'ajax_pagination.javascript_warnings' do
+      if AjaxPagination.warnings.nil? # if not defined
+        AjaxPagination.warnings = Rails.env == 'development' # default setting
+      end
+    end
   end
 end

data/lib/ajax_pagination/version.rb

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

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

@@ -14,16 +14,6 @@ if (History && History.enabled) {
       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
 
-      // semi-public API function - registers new content just loaded to display (if not stale)
-      // not actually public, because it is used by the AJAX Pagination gem itself. However, the other variables/functions should not be accessible by other parts of the gem, whereas this function is accessible by newly loaded scripts.
-      $.ajaxPagination = function(pagination_name,requesturl,content) {
-        if (pagination_loader_state[pagination_name] == requesturl) {
-          //pagination_content_state[pagination_name] = pagination_loader_state[pagination_name];
-          delete pagination_loader_state[pagination_name]; // not waiting for page anymore
-          $("#" + pagination_name + "_paginated_section").html(content);
-        }
-        // else content is stale
-      };
       function display_pagination_loader(pagination_name) {
         if (pagination_loader_state[pagination_name] != undefined) return; // if already loading, don't reshow loader
         var paginated_section = $('#' + pagination_name + '_paginated_section');
@@ -33,7 +23,7 @@ if (History && History.enabled) {
         var height = paginated_content.height();
         // setup loading look
         var img = document.createElement("IMG");
-        img.src = "<%= asset_path "ajax-loader.gif" %>";
+        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");
@@ -50,16 +40,48 @@ if (History && History.enabled) {
       function swapPage(pagination_name,requesturl) { // swaps the page at pagination_name to that from requesturl
         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});
+        //$.ajax(requesturl,{dataType:'script',cache:true});
+        $.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);
+          }
+        });
       }
       $('body').on("click", ".pagination a, .ajaxpagination a", function() {
         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) pagination_name = /^(.*)_paginated_section$/.exec($(this).closest(".paginated_section").attr("id"))[1]; // if data-pagination not present, search up the tree for a suitable section
-        if ($("#" + pagination_name + "_paginated_section").length != 1) return true; // something wrong, cannot find unique section to load page into
-        if (pagination_name == null) return true; // pagination not set up properly
-        var requesturl = $.param.querystring(this.href,{pagination:pagination_name}); // by default, adds ?pagination=page
-        swapPage(pagination_name,requesturl);
+        if (pagination_name === undefined) {
+          pagination_name = /^(.*)_paginated_section$/.exec($(this).closest(".paginated_section").attr("id")); // if data-pagination not present, search up the tree for a suitable section
+          if (pagination_name == null) {
+            <% if AjaxPagination.warnings %>
+              alert("AJAX Pagination warning:\nNo pagination section name given for link, and none could be implicitly assigned, AJAX cancelled for this request");
+            <% end %>
+            return true; // pagination not set up properly
+          }
+          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
+        }
+        //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);
         return false;
@@ -72,13 +94,13 @@ if (History && History.enabled) {
           var pagination_name = /^(.*)_paginated_section$/.exec($(this).attr("id"))[1];
           if (pagination_name == null) return; // pagination not set up properly
 
-          // if data-reload is not defined, the use default reload test
-          if ($(this).data('reload') === undefined) {
+          // if data-pagination is not defined, the use default reload test
+          if ($(this).data('pagination') === 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('reload');
+            var reload = $(this).data('pagination');
             if (!(reload instanceof Array)) reload = new Array(reload);
             var changed = false;
             for (i=0;i<reload.length;i++) {

data/lib/generators/ajax_pagination/install_generator.rb

@@ -0,0 +1,13 @@
+module AjaxPagination
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("../../templates",__FILE__)
+
+      desc "Creates a Ajax Pagination initializer"
+
+      def initializer
+        template "ajax_pagination.rb", "config/initializers/ajax_pagination.rb"
+      end
+    end
+  end
+end

data/lib/generators/templates/ajax_pagination.rb

@@ -0,0 +1,12 @@
+AjaxPagination.config do |config|
+  # uncomment to change default loading image file, located in assets/images.
+  # config.loading_image = "ajax-loader.gif"
+
+  # whether javascript warnings are on, these present themselves as alerts
+  # by default, warnings are active only if the environment is development
+  # to configure by environment otherwise, this configuration needs to be added to the environment specific files
+  # uncomment to turn warnings on in all environments
+  # config.warnings = true
+  # or to turn off in all environments
+  # config.warnings = false
+end

data/spec/ajax_pagination/controller_additions_spec.rb

@@ -2,19 +2,23 @@ require "spec_helper"
 
 describe AjaxPagination::ControllerAdditions do
   def stub_pagination(name)
-    @controller.stub!(:params).and_return({:pagination => name})
+    @controller.stub!(:params).and_return({:pagination => name, :controller => "dummycontroller"})
   end
-  def stub_request_format_js(bool)
-    @controller.stub!(:request).and_return(stub(:format => stub(:js? => bool)))
+  def stub_request_format_html(bool)
+    @controller.stub!(:request).and_return(stub(:format => stub(:html? => bool)))
+  end
+  def stub_lookup_context(result)
+    @controller.stub!(:lookup_context).and_return(stub(:find_all => result))
   end
   before :each do
     @controller_class = Class.new
     @controller = @controller_class.new
     @controller.stub!(:params).and_return({})
-    stub_request_format_js(false)
+    stub_request_format_html(false)
     @controller_class.send(:include, AjaxPagination::ControllerAdditions)
     @formatter = Class.new
-    @formatter.stub!(:js).and_return(0,1,2,3,4,5,6,7,8,9,10) # to detect how many times the function was called
+    @formatter.stub!(:html).and_return(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15) # to detect how many times the function was called
+    stub_lookup_context([]) # no partial matching
   end
 
   describe 'ajax_pagination' do
@@ -23,19 +27,26 @@ describe AjaxPagination::ControllerAdditions do
       @controller.ajax_pagination(@formatter, :pagination => :page).should be_false
       @controller.ajax_pagination(@formatter, :pagination => 'page').should be_false
       @controller.ajax_pagination(@formatter, :pagination => 'page2').should be_false
-      @formatter.js.should == 0
+      @formatter.html.should == 0
     end
     it 'should render when pagination parameter matches' do
       stub_pagination('page')
       @controller.ajax_pagination(@formatter).should be_true
-      @formatter.js.should == 1 # detects js function was called once (but checking also calls the function) ...
+      @formatter.html.should == 1 # detects html function was called once (but checking also calls the function) ...
       @controller.ajax_pagination(@formatter, :pagination => :page).should be_true
-      @formatter.js.should == 3 # ... which is why the next check should be 2 more js function calls
+      @formatter.html.should == 3 # ... which is why the next check should be 2 more html function calls
       @controller.ajax_pagination(@formatter, :pagination => 'page').should be_true
-      @formatter.js.should == 5
+      @formatter.html.should == 5
       stub_pagination('pageX')
       @controller.ajax_pagination(@formatter, :pagination => 'pageX').should be_true
-      @formatter.js.should == 7
+      @formatter.html.should == 7
+      stub_lookup_context(['matching_partial_found'])
+      @controller.ajax_pagination(@formatter, :pagination => 'pageX').should be_true
+      @formatter.html.should == 9
+      stub_pagination('page')
+      @controller.ajax_pagination(@formatter).should be_true
+      @formatter.html.should == 11
+
     end
     it 'should not render when pagination parameter does not match' do
       stub_pagination('notpage')
@@ -44,20 +55,20 @@ describe AjaxPagination::ControllerAdditions do
       @controller.ajax_pagination(@formatter, :pagination => 'page').should be_false
       stub_pagination('notpageX')
       @controller.ajax_pagination(@formatter, :pagination => 'pageX').should be_false
-      @formatter.js.should == 0
+      @formatter.html.should == 0
     end
   end
 
   describe 'ajax_pagination_displayed?' do
-    it 'should display partial when format is not js' do
+    it 'should display partial when format is not html' do
       @controller.ajax_pagination_displayed?.should be_true
     end
-    it 'should display partial when format is js but pagination is not defined' do
-      stub_request_format_js(true)
+    it 'should display partial when format is html but pagination is not defined' do
+      stub_request_format_html(true)
       @controller.ajax_pagination_displayed?.should be_true
     end
-    it 'should display partial when .js?pagination=pagename' do
-      stub_request_format_js(true)
+    it 'should display partial when .html?pagination=pagename' do
+      stub_request_format_html(true)
       stub_pagination('page')
       @controller.ajax_pagination_displayed?.should be_true
       stub_pagination('page2')
@@ -65,8 +76,8 @@ describe AjaxPagination::ControllerAdditions do
       stub_pagination('page3')
       @controller.ajax_pagination_displayed?(:page3).should be_true
     end
-    it 'should not display partial when .js?pagination!=pagename' do
-      stub_request_format_js(true)
+    it 'should not display partial when .html?pagination!=pagename' do
+      stub_request_format_html(true)
       stub_pagination('notpage')
       @controller.ajax_pagination_displayed?.should be_false
       stub_pagination('notpage2')

data/spec/ajax_pagination/helper_additions_spec.rb

@@ -20,9 +20,9 @@ describe AjaxPagination::HelperAdditions do
       @view.should_receive(:render).with('page2')
       @view.ajax_pagination :pagination => 'page2' # renders the partial named :pagination if :partial not defined
       @view.should_receive(:render).with('page3')
-      @view.ajax_pagination :partial => 'page3' # if partial defined, renders partial
+      @view.ajax_pagination :render => 'page3' # if partial defined, renders partial
       @view.should_receive(:render).with('pageX')
-      @view.ajax_pagination :pagination => 'page10', :partial => 'pageX' # even if pagination also defined as different value
+      @view.ajax_pagination :pagination => 'page10', :render => 'pageX' # even if pagination also defined as different value
     end
   end
   describe 'ajax_pagination_loadzone' do

data/spec/ajax_pagination/integration/ajaxpaginate_spec.rb

@@ -21,6 +21,7 @@ describe 'paginating with javascript on', :js => true do
     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)
@@ -30,4 +31,34 @@ describe 'paginating with javascript on', :js => true do
     sleep(0.5)
     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
+    page.should have_xpath("//img[@class='ajaxloader' and @src = '/assets/myajax-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)
+    click_link 'About'
+    sleep(0.5)
+    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)
+    page.should have_no_selector('.ajaxloader')
+    page.should have_selector('#aboutpagetitle')
+    page.evaluate_script('window.history.forward();') # forward to readme
+    sleep(0.5)
+    page.should have_selector('#readmepagetitle')
+    page.evaluate_script('window.history.go(-2);') # back to changelog page 2
+    sleep(0.5)
+    page.should have_no_selector('#aboutpagetitle')
+    page.evaluate_script('window.history.forward();') # forward to about
+    sleep(0.5)
+    page.should have_selector('#aboutpagetitle')
+  end
 end

data/spec/rails_app/Gemfile

@@ -39,4 +39,4 @@ gem 'ajax_pagination', :path => "../.."
 # gem 'capistrano'
 
 # To use debugger
-# gem 'ruby-debug'
+gem 'ruby-debug'

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

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

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

@@ -7,7 +7,7 @@ class ChangelogController < ApplicationController
     respond_to do |format|
       format.html # index.html.erb
       ajax_pagination(format)
-      ajax_pagination format, :pagination => :menu, :partial => {:file => "changelog/index"}
+      ajax_pagination format, :pagination => :menu
     end
   end
 end

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

@@ -1,23 +1,21 @@
 class PagesController < ApplicationController
+  respond_to :html, :js, :only => :about
+
   def readme
     @readme = IO.read(File.expand_path("../../../../../README.md",__FILE__))
     respond_to do |format|
       format.html
-      ajax_pagination format, :pagination => :menu, :partial => {:file => "pages/readme"}
+      ajax_pagination format, :pagination => :menu, :render => {:file => "pages/readme"}
     end
   end
 
   def about
-    respond_to do |format|
-      format.html
-      ajax_pagination format, :pagination => :menu, :partial => {:file => "pages/about"}
-    end
   end
 
   def welcome
     respond_to do |format|
       format.html
-      ajax_pagination format, :pagination => :menu, :partial => {:file => "pages/welcome"}
+      ajax_pagination format, :pagination => :menu
     end
   end
 end

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

@@ -1,4 +1,5 @@
 class PostsController < ApplicationController
+  ajax_pagination :pagination => 'page'
   # GET /posts
   # GET /posts.json
   def index
@@ -7,9 +8,8 @@ class PostsController < ApplicationController
     respond_to do |format|
       format.html # index.html.erb
       format.json { render :json => @posts }
-      ajax_pagination(format)
       ajax_pagination format, :pagination => :upcomingpage
-      ajax_pagination format, :pagination => :menu, :partial => {:file => "posts/index"}
+      ajax_pagination format, :pagination => :menu
     end
   end
 
@@ -17,7 +17,6 @@ class PostsController < ApplicationController
   # GET /posts/1.json
   def show
     @post = Post.find(params[:id])
-
     respond_to do |format|
       format.html # show.html.erb
       format.json { render :json => @post }

data/spec/rails_app/config/initializers/ajax_pagination.rb

@@ -0,0 +1,12 @@
+AjaxPagination.config do |config|
+  # uncomment to change default loading image file, located in assets/images.
+  config.loading_image = "myajax-loader.gif"
+
+  # whether javascript warnings are on, these present themselves as alerts
+  # by default, warnings are active only if the environment is development
+  # to configure by environment otherwise, this configuration needs to be added to the environment specific files
+  # uncomment to turn warnings on in all environments
+  # config.warnings = true
+  # or to turn off in all environments
+  # config.warnings = false
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ajax_pagination
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-20 00:00:00.000000000 Z
+date: 2012-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &10548120 !ruby/object:Gem::Requirement
+  requirement: &17693300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *10548120
+  version_requirements: *17693300
 - !ruby/object:Gem::Dependency
   name: rspec-rails
-  requirement: &10547700 !ruby/object:Gem::Requirement
+  requirement: &17692880 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *10547700
+  version_requirements: *17692880
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &10547260 !ruby/object:Gem::Requirement
+  requirement: &17692440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *10547260
+  version_requirements: *17692440
 - !ruby/object:Gem::Dependency
   name: will_paginate
-  requirement: &10546680 !ruby/object:Gem::Requirement
+  requirement: &17691880 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *10546680
+  version_requirements: *17691880
 - !ruby/object:Gem::Dependency
   name: capybara
-  requirement: &10546160 !ruby/object:Gem::Requirement
+  requirement: &17691360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *10546160
+  version_requirements: *17691360
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &10545360 !ruby/object:Gem::Requirement
+  requirement: &17690540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,21 +76,21 @@ dependencies:
         version: '3.1'
   type: :runtime
   prerelease: false
-  version_requirements: *10545360
+  version_requirements: *17690540
 - !ruby/object:Gem::Dependency
   name: jquery-rails
-  requirement: &10575320 !ruby/object:Gem::Requirement
+  requirement: &17720620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 1.0.17
   type: :runtime
   prerelease: false
-  version_requirements: *10575320
+  version_requirements: *17720620
 - !ruby/object:Gem::Dependency
   name: jquery-historyjs
-  requirement: &10574740 !ruby/object:Gem::Requirement
+  requirement: &17720080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -98,7 +98,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *10574740
+  version_requirements: *17720080
 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
@@ -127,6 +127,8 @@ files:
 - lib/ajax_pagination/version.rb
 - lib/assets/images/ajax-loader.gif
 - lib/assets/javascripts/ajax_pagination.js.erb
+- lib/generators/ajax_pagination/install_generator.rb
+- lib/generators/templates/ajax_pagination.rb
 - spec/PORT
 - spec/ajax_pagination/controller_additions_spec.rb
 - spec/ajax_pagination/helper_additions_spec.rb
@@ -137,6 +139,7 @@ files:
 - spec/rails_app/Gemfile
 - spec/rails_app/README.rdoc
 - spec/rails_app/Rakefile
+- spec/rails_app/app/assets/images/myajax-loader.gif
 - spec/rails_app/app/assets/javascripts/application.js
 - spec/rails_app/app/assets/javascripts/posts.js
 - spec/rails_app/app/assets/stylesheets/application.css
@@ -174,6 +177,7 @@ files:
 - spec/rails_app/config/environments/development.rb
 - spec/rails_app/config/environments/production.rb
 - spec/rails_app/config/environments/test.rb
+- spec/rails_app/config/initializers/ajax_pagination.rb
 - spec/rails_app/config/initializers/backtrace_silencers.rb
 - spec/rails_app/config/initializers/inflections.rb
 - spec/rails_app/config/initializers/mime_types.rb