ajax_pagination 0.0.2 → 0.1.0

data/.gitignore

@@ -2,3 +2,6 @@
 .bundle
 Gemfile.lock
 pkg/*
+*~
+*.swp
+

data/.travis.yml

@@ -0,0 +1,16 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - rbx-18mode
+  - rbx-19mode
+# Can't get to work (if anybody wants to fix this, please do)
+#  - jruby-18mode # JRuby in 1.8 mode
+#  - jruby-19mode # JRuby in 1.9 mode
+
+# uncomment this line if your project needs to run something other than `rake`:
+before_script: # for Selenium RSpec tests
+  - "export DISPLAY=:99.0"
+  - "sh -e /etc/init.d/xvfb start"
+script: rake travis

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+## 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:
+
+```sh
+bundle install
+bundle exec rails server
+```
+
+* Added more mock changelog model and controller (including various dummy informational pages) to test application.
+* Modified controller and helper additions, so that they are more suitable for ajaxifying menu navigations.
+* Added loadzone option to the ajax_pagination helper, so that ajax_pagination_loadzone does not need to be used.
+* Modularised javascript further so only a single function is globally accessible through the jQuery object.
+* Example application shows nested AJAX pagination, and multiple AJAX paginated sections in one page.
+* Default loading image added to gem.
+* urlregex parameter on the reload option extended with urlpart, to make it easier to specify a regular expression on only part of the url. Gem now depends on jquery.url.js as well (vendorized automatically, same as with the jquery.ba-bbq.js dependency).
+* Added some RSpec tests on example application with and without javascript
+* Make rake travis task for easy testing (automatically starts up daemonized webrick server for selenium tests, also cleans up the daemon). The test script will clone the development database to create a test database. There is a bundling problem with the external javascript dependencies (those inside other gems), so the script also copies the javascript files into a local vendor/assets/javascripts directory (keeping them up-to-date).
+
 ## v0.0.2
 * Semi-transparent white rectangle changed to completely transparent rectangle. Instead, the opacity of the content behind it is lowered to achieve the same effect, but works better on backgrounds of other colours as well.
 * Added rdoc comments to code
@@ -5,5 +24,5 @@
 
 ## v0.0.1
 
-* initial release
+* initial release.
 

data/README.md

@@ -1,4 +1,5 @@
 # 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.
 
@@ -68,13 +69,13 @@ 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". For example:
+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:
 
 ```html
 <div class="ajaxpagination"><a href="#">My ajaxified link</a></div>
 ```
 
-If you are using will_paginate, you can simply put this in the partial (so that the new links get reloaded when the page changes):
+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
 <%= will_paginate @objects, :params => { :pagination => nil } %>
@@ -84,6 +85,25 @@ Note: It is recommended to set the pagination parameter to nil. When AJAX pagina
 
 Now, AJAX Pagination will automatically call the controller for new content when an ajaxified link is clicked.
 
+If the links are outside the partial, you will need to also let AJAX Pagination know what content container should be reloaded when the links are followed. In this case, the div with ajaxpagination class should define the data-pagination attribute, the value corresponding to the name of the pagination content, for example you can do the following (which ajaxifies the menu navigation links):
+
+```erb
+<div class="ajaxpagination menu" data-pagination="menu">
+  <ul>
+    <li><%= link_to "Home", root_url %></li>
+    <li><%= link_to "Posts", posts_url %></li>
+    <li><%= link_to "Changelog", changelog_url %></li>
+    <li><%= link_to "Readme", pages_readme_url %></li>
+    <li><%= link_to "About", pages_about_url %></li>
+  </ul>
+</div>
+<%= ajax_pagination :pagination => "menu", :reload => {:urlpart => "path", :urlregex => "^.*$"} do %>
+  <%= yield %>
+<% 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.
+
 ### 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.
@@ -105,7 +125,7 @@ The pagination should now work.
 
 ### Loading visualization
 
-AJAX Pagination can also add a loading image and partially blanking out of the paginated content. To do this, wrap all the content you want to cover with <tt>ajax_pagination_loadzone</tt>. For example, in the partial, you might have:
+AJAX Pagination can also add a loading image and partially blanking out of the paginated content. To do this, you can wrap all the content you want to cover with <tt>ajax_pagination_loadzone</tt>. For example, in the partial, you might have:
 
 ```erb
 <%= will_paginate @objects, :params => { :pagination => nil } %>
@@ -120,6 +140,16 @@ 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)
 
+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:
+
+```erb
+<%= ajax_pagination :pagination => "menu", :reload => {:urlpart => "path", :urlregex => "^.*$"}, :loadzone => true do %>
+  <%= yield %>
+<% end %>
+```
+
+In this case, whatever is inside the yield will not need to call ajax_pagination_loadzone.
+
 ### Content reloading
 
 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.
@@ -151,6 +181,20 @@ 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"}]' %>
 ```
+## Example Application
+This gem contains an example application (actually, it is there also for testing purposes), however it is nevertheless a good example.
+
+Clone this repository, and run the server, using:
+
+```sh
+git clone git://github.com/ronalchn/ajax_pagination.git
+cd ajax_pagination
+cd spec/rails_app
+bundle install
+bundle exec rails server
+```
+
+Then point your browser to http://localhost:3000/
 
 ## AJAX Call
 The AJAX Call is triggered by a link wrapped in any container with a certain class. The AJAX Call is to the same address, but with the ?pagination=NAME parameter added. The format requested is javascript. If the controller also returns javascript for other uses, AJAX Pagination does not necessarily prevent such uses. The ajax_pagination(format, :pagination => "page") function in the controller handles the AJAX Call when the format is javascript, and the ?pagination parameter is set to the correct string. It also returns true if the pagination parameter matches. Therefore, you can use use the javascript format when it does not match, as shown below:
@@ -173,9 +217,9 @@ end
 ```
 
 ## Javascript Dependency
-As well as the included ajax_pagination.js file, this gem uses jquery.ba-bbq.js, a jquery plugin. This is included in the gem as an asset already to simplify installation. ajax_pagination.js will automatically require jquery.ba-bbq.js.
+As well as the included ajax_pagination.js file, this gem uses jquery.ba-bbq.js and jquery.url.js, which are jquery plugins. They are included in the gem as assets already to simplify installation. ajax_pagination.js will automatically require jquery.ba-bbq.js, and jquery.url.js.
 
-However, if you are already using this (especially a different version of this), simply ensure that your file is named jquery.ba-bbq.js as well, so that it overrides the file in the gem.
+However, if you are already using them (especially if using a different version), simply ensure that your assets directory contains javascript files of the same name to shadow/override the file in the gem.
 
 The other javascript dependencies rely on gems: jquery-rails, and jquery-historyjs. So if they are used, AJAX Pagination should play well with other gems using the libraries.
 

data/Rakefile

@@ -3,3 +3,19 @@ require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
+task :travis do
+  serverport = IO.read(File.expand_path("../spec/PORT",__FILE__)).strip # port number that we are using
+  system("cp spec/rails_app/db/development.sqlite3 spec/rails_app/db/test.sqlite3") # take a copy of the development database
+  system("mkdir -p spec/rails_app/vendor/assets/javascripts") # directory to plonk javascripts from dependent gems
+  # obtain jquery javascript assets (this is because sprockets cannot find these files otherwise, when going through nested bundles)
+  # Note that the spec/rails_app/vendor directory is .gitignore because these are generated files
+  system("cp `bundle show jquery-rails`/vendor/assets/javascripts/* spec/rails_app/vendor/assets/javascripts/")
+  system("cp `bundle show jquery-historyjs`/vendor/assets/javascripts/* spec/rails_app/vendor/assets/javascripts/")
+  system("(cd spec/rails_app/ && RAILS_ENV=test bundle exec rails server -d --port=#{serverport})") # daemonized rails server
+  system("bundle exec rake spec")
+  unless $?.exitstatus == 0
+    system("kill -9 `lsof -i :#{serverport} -t`") # kills rails server
+    raise "spec failed!" 
+  end
+  system("kill -9 `lsof -i :#{serverport} -t`") # kills rails server
+end

data/ajax_pagination.gemspec

@@ -19,8 +19,11 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   # specify any dependencies here; for example:
-  s.add_development_dependency "rspec"
-  # s.add_runtime_dependency "rest-client"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec-rails"
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "will_paginate"
+  s.add_development_dependency "capybara"
 
   s.add_runtime_dependency "rails", '>= 3.1'
   s.add_runtime_dependency "jquery-rails", '>= 1.0'

data/lib/ajax_pagination/controller_additions.rb

@@ -23,17 +23,66 @@ module AjaxPagination
     #   Defaults to "page"
     #
     # [:+partial+]
-    #   Changes the partial that is returned by this response. Defaults to options [:pagination].
+    #   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.
+    #
+    #     def welcome
+    #       respond_to do |format|
+    #         format.html
+    #         ajax_pagination format, :pagination => :menu, :partial => {:file => "pages/welcome"}
+    #       end
+    #     end
     #
     def ajax_pagination(format,options = {})
-      if params[:pagination] == (options[:pagination] || 'page')
+      if params[:pagination] == (options[:pagination] || 'page').to_s
         partial = options[:partial] || params[:pagination]
-        format.js { render :inline => "ajaxPagination.display_pagination_content(\"#{params[:pagination]}\",\"#{request.url}\",\"<%= raw escape_javascript(render(\"#{partial}\")) %>\");" }
+        format.js { render :inline => "jQuery.ajaxPagination(\"#{params[:pagination]}\",\"#{request.url}\",\"<%= raw escape_javascript(render(partial)) %>\");", :locals => { :partial => partial } }
         return true
       else
         return false
       end
     end
+
+    # 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
+    # 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
+    # be required if a certain pagination partial is displayed.
+    #
+    # For example, suppose an index page contains two sets of pagination partials, one for upcoming posts, and one for published
+    # posts, then you might use:
+    # 
+    #   class PostsController < ApplicationController
+    #     def index
+    #       if ajax_pagination_displayed? do
+    #         @posts = Post.published
+    #         @posts.each do |post|
+    #           post.heavycomputation
+    #         end
+    #       end
+    #       if current_user.is_admin && ajax_pagination_displayed? :upcomingpage do
+    #         @upcomingposts = Post.upcoming
+    #         @upcomingposts.each do |post|
+    #           post.heavycomputation
+    #         end
+    #       end
+    #       respond_to do |format|
+    #         format.html # index.html.erb
+    #         ajax_pagination format
+    #         ajax_pagination format, :pagination => 'upcomingpage'
+    #       end
+    #     end
+    #   end
+    #
+    # 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)
+    end
   end
 end
 if defined? ActionController

data/lib/ajax_pagination/helper_additions.rb

@@ -1,3 +1,8 @@
+begin
+  require 'will_paginate' if Gem::Specification.find_by_name('will_paginate') # needed for testing dummy application
+rescue Gem::LoadError # in case using version without fix for this
+end
+
 module AjaxPagination
   # This module is automatically added to all views, providing helper methods.
   module HelperAdditions
@@ -13,6 +18,23 @@ module AjaxPagination
     #   
     #   <%= link_to 'New Comment', new_comment_path %>
     #
+    # If you prefer to can render yourself, or call another function instead (useful for using this in the
+    # application layout), you can pass in a block. Any content wrapped by the pagination tag will be changed
+    # when paginating. A possible way to use this function by passing a block in an application layout is shown:
+    # 
+    #   <div class="ajaxpagination menu" data-pagination="menu">
+    #     <ul>
+    #       <li><%= link_to "Home", root_url %></li>
+    #       <li><%= link_to "Posts", posts_url %></li>
+    #       <li><%= link_to "Changelog", changelog_url %></li>
+    #       <li><%= link_to "Readme", pages_readme_url %></li>
+    #       <li><%= link_to "About", pages_about_url %></li>
+    #     </ul>
+    #   </div>
+    #   <%= ajax_pagination :pagination => "menu", :reload => {:urlpart => "path", :urlregex => "^.*$"} do %>
+    #     <%= yield %>
+    #   <% end %>
+    #
     # Options:
     # [:+pagination+]
     #   Changes the pagination name, which is used for requesting new content, and to uniquely identify the
@@ -21,7 +43,8 @@ module AjaxPagination
     #
     # [:+partial+]
     #   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.
+    #   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.
     #
     # [:+reload+]
     #   Used to detect whether the partial needs reloading, based on how the url changes. When pagination links are
@@ -37,7 +60,11 @@ module AjaxPagination
     #   If passed a hash of the form :+urlregex+ => "regularexpression", AJAX Pagination will apply the regular
     #   expression to the url. If a particular subexpression of the match changes, the partial is reloaded. The
     #   subexpression used defaults to the whole match. If the hash includes :+regexindex+ => N, the Nth subexpression
-    #   is used.
+    #   is used. If the hash also includes :+urlpart+, then the regular expression will only be applied to part of the
+    #   url. The part it is applied to depends on the string passed. Allowed strings are any attributes as given at
+    #   https://github.com/allmarkedup/jQuery-URL-Parser. Possible attributes include: "source", "protocol", "host",
+    #   "port", "relative", "path", "directory", "file", "query". Notice in the above example for the application
+    #   layout, how :urlpart => "path" is passed as a reload condition.
     #   
     #   Different parts of the url can be watched for any changes, by passing an array of hashes. For example:
     #   
@@ -45,6 +72,10 @@ module AjaxPagination
     #   
     #   If nil, AJAX Pagination acts as if it was passed {:query => options [:pagination]}.
     #
+    # [:+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.
+    #
     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
@@ -56,8 +87,26 @@ module AjaxPagination
       when "Hash", "Array"
         divoptions["data-reload"] = reload.to_json
       end
+      if options[:loadzone]
+        divoptions[:class] = "paginated_section paginated_content"
+        divoptions[:style] = "position: relative;"
+      end
       content_tag :div, divoptions do
-        render partial
+        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
+        else
+          if block_given?
+            yield
+          else
+            render partial
+          end
+        end
       end
     end
 
@@ -78,7 +127,7 @@ module AjaxPagination
     #   <% end %>
     #
     def ajax_pagination_loadzone()
-      content_tag :div, :class => "paginated_content", :style => "position: relative" do
+      content_tag :div, :class => "paginated_content", :style => "position: relative;" do
         content_tag :div do # for changing the opacity
           yield
         end

data/lib/ajax_pagination/version.rb

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

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

@@ -1,4 +1,5 @@
 //= require jquery.ba-bbq
+//= require jquery.url
 
 /* 
  * AJAX Pagination: Ajaxifying your pagination links
@@ -8,23 +9,33 @@
  * Distributed under the LGPL license
  */
 if (History && History.enabled) {
-  var ajaxPagination;
-  $(document).ready(function () {
-    ajaxPagination = new function() {
-      this.pagination_loader_state = new Array(); // the page we are waiting for
-      //this.pagination_stack = new Array(); // stack of request urls in history (to get state of url we came from)
-      this.pagination_url = location.href; // url we came from, so we can see transitions of the url
+  jQuery(document).ready(function () {
+    (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
 
+      // 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 (this.pagination_loader_state[pagination_name] != undefined) return; // if already loading, don't reshow loader
+        if (pagination_loader_state[pagination_name] != undefined) return; // if already loading, don't reshow loader
         var paginated_section = $('#' + pagination_name + '_paginated_section');
-        var paginated_content = paginated_section.children(".paginated_content").first(); // don't want to support multiple loader images
+        var paginated_content;
+        if (paginated_section.hasClass("paginated_content")) paginated_content = paginated_section; // if the whole section is a loading zone
+        else paginated_content = paginated_section.children(".paginated_content").first(); // don't want to support multiple loader images
         var height = paginated_content.height();
         // setup loading look
         var img = document.createElement("IMG");
         img.src = "<%= asset_path "ajax-loader.gif" %>";
         var margin = Math.round(height>400?100:(height/4));
-        $(img).css({'margin': margin + 'px', 'max-height': (height/2) + 'px'});
+        $(img).css({'margin': margin + 'px', 'max-height': (3*height/4) + 'px'}).addClass('ajaxloader');
         var div = document.createElement("DIV");
         $(div).append(img);
         $(div).css({'position': 'absolute', 'left': 0, 'top': 0, 'width': '100%', 'height': '100%', 'text-align': 'center', 'opacity': 0.9});
@@ -36,33 +47,26 @@ if (History && History.enabled) {
           $('body').scrollTop(paginated_section.offset().top);
         }
       }
-
-      this.display_pagination_content = function(pagination_name,requesturl,content) {
-        if (this.pagination_loader_state[pagination_name] == requesturl) {
-          //pagination_content_state[pagination_name] = pagination_loader_state[pagination_name];
-          delete this.pagination_loader_state[pagination_name]; // not waiting for page anymore
-          $("#" + pagination_name + "_paginated_section").html(content);
-        }
-        // else content is stale
-      };
-
       function swapPage(pagination_name,requesturl) { // swaps the page at pagination_name to that from requesturl
-        display_pagination_loader.call(this,pagination_name);
-        this.pagination_loader_state[pagination_name] = requesturl; // remember which page number we are waiting for
+        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});
       }
       $('body').on("click", ".pagination a, .ajaxpagination a", function() {
-        var pagination_name = /^(.*)_paginated_section$/.exec($(this).closest(".paginated_section").attr("id"))[1];
-        if (pagination_name == null) return; // pagination not set up properly
+        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.call(ajaxPagination,pagination_name,requesturl);
-        ajaxPagination.pagination_url = this.href;
+        swapPage(pagination_name,requesturl);
+        pagination_url = this.href;
         History.pushState(null,document.title,this.href);
         return false;
       });
 
       History.Adapter.bind(window,'popstate',function(){ // popstate, but can work with hash changes as well
-        var from = ajaxPagination.pagination_url, to = location.href; // from what state to what other state
+        var from = pagination_url, to = location.href; // from what state to what other state
 
         $(".paginated_section").each(function(){
           var pagination_name = /^(.*)_paginated_section$/.exec($(this).attr("id"))[1];
@@ -82,10 +86,16 @@ if (History && History.enabled) {
                 if ($.deparam.querystring(from)[reload[i].query] !== $.deparam.querystring(to)[reload[i].query]) changed = true;
               }
               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);
+                  if (typeof(fstr)!="string" || typeof(tstr)!="string") continue; // skip
+                }
                 var index = 0;
                 if (reload[i].regexindex !== undefined) index = reload[i].regexindex;
                 var regex = new RegExp(reload[i].urlregex);
-                var frommatch = regex.exec(from), tomatch = regex.exec(to);
+                var frommatch = regex.exec(fstr), tomatch = regex.exec(tstr);
                 if (frommatch != null && frommatch.length>=index) frommatch = frommatch[index];
                 if (tomatch != null && tomatch.length>=index) tomatch = tomatch[index];
                 if (frommatch !== tomatch) changed = true;
@@ -95,14 +105,14 @@ 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.call(ajaxPagination,pagination_name,requesturl);
+          swapPage(pagination_name,requesturl);
         });
 
-        ajaxPagination.pagination_url = location.href; // update url (new url recognised)
+        pagination_url = location.href; // update url (new url recognised)
       });
 
-      //History.Adapter.trigger(window,"popstate"); // update stuff on page load
-    };
+      History.Adapter.trigger(window,"popstate"); // update stuff on page load
+    })( jQuery );
   });
 }