rails_stackview 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1dcc75e8d87f6311a1b7c4bdca4f7b0705ed41db
-  data.tar.gz: fda9b0a44729a94c66949106518e2b9bd7b77f48
+  metadata.gz: f90b15df352fff73c0c6ec5db8241438fcdca875
+  data.tar.gz: 4d8e7e3d5e59c6d9b9230a25974948a6802df5d0
 SHA512:
-  metadata.gz: 2d7c495b8684b66d9e544643c1ae9ee8d1d855e951c77e135e1d44a55baa4341303894944249556195a4b6b964f58b89441eeaba4b22331d0106c0afb504e31b
-  data.tar.gz: 920ce32703b2f2a27cb79b3385b8bd4a3f25d7944707236737014858c877dd3cbc6e8ad6f0e02c78b6e4b654acd9ae2d3fc8079d0432af3f955c3352a8ba57f6
+  metadata.gz: e9f76890644194095bb344aa0bc6fdb6c94df10f3e31d375d39191a090d40eb30a98e56da750768bb93db88147962df151ed85f55c13b062871661d9f4758cd5
+  data.tar.gz: 00bc0f53ebfa77f1402549e4e5639a4f23eedcf943abed79b9a0e1138546f67a0e0ac3d4e3c356434075af2f3dbc2f348dad5f3b857b46ae3b26dd652b753b1c

data/README.md

@@ -1,8 +1,6 @@
-# RailsStackview
-
-IN PROGRESS UNDER DEVELOPMENT NOT USABLE YET
+[![Build Status](https://travis-ci.org/jrochkind/rails_stackview.svg?branch=master)](https://travis-ci.org/jrochkind/rails_stackview) [![Gem Version](https://badge.fury.io/rb/rails_stackview.svg)](http://badge.fury.io/rb/rails_stackview)
 
-**Tools** for integrating the Harvard Innovation Lab [stackview](https://github.com/harvard-lil/stackview) Javascript into a Rails app. 
+# RailsStackview
 
 This is not an out of the box solution, integrating it into your app will require some development.
 

data/lib/rails_stackview/version.rb

@@ -1,3 +1,3 @@
 module RailsStackview
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

data/vendor/assets/README.md

@@ -0,0 +1,16 @@
+Asset files from stackview source are included in rails_stackview under 
+`./vendor/assets` subdirs. 
+
+To refresh with recent source, do a git checkout of stackview somewhere, then
+from rails_stackview root dir, run:
+
+    RUBYLIB=./source_tools/ rails generate copy_stackview_assets path_to_stackview_source -f
+
+The git SHA of stackview source that was copied into rails_stackview will be
+saved at ./vendor/assets/stackview.sha
+
+Part of the routine for copying stackview assets will also replace all
+CSS `url()` in stackview CSS source with rails-sass `asset-url` calls, to
+play well with the asset pipeline.  To support this, the stackview
+CSS will be copied as a `.sass` file, even though we are copying generated
+stackview CSS, and it's not otherwise sass. 

data/vendor/assets/javascripts/jquery.stackview.js

@@ -0,0 +1,21 @@
+// Not copied from stackview directly, our own rails_stackview
+// file to use sprockets to include JS src copied from stackview
+//
+// The list of assets is explicit below to preserve any neccesary ordering. 
+// If stackview adds more JS source files, you will have to update
+// this list below, to keep it in sync with the list in stackview's
+// own Makefile. 
+//
+//= require ./stackview/microtemplating.js
+//= require ./stackview/jquery.easing.1.3.js
+//= require ./stackview/jquery.stackview.base.js 
+//= require ./stackview/jquery.stackview.infinite.js
+//= require ./stackview/jquery.stackview.navigation.js
+//= require ./stackview/jquery.stackview.ministack.js
+//= require ./stackview/jquery.stackview.stackcache.js
+//= require ./stackview/jquery.stackview.templates.js
+//= require ./stackview/types/book.js
+//= require ./stackview/types/serial.js
+//= require ./stackview/types/soundrecording.js
+//= require ./stackview/types/videofilm.js
+//= require ./stackview/types/webpage.js

data/vendor/assets/javascripts/stackview/jquery.easing.1.3.js

@@ -0,0 +1,205 @@
+/*
+ * jQuery Easing v1.3 - http://gsgd.co.uk/sandbox/jquery/easing/
+ *
+ * Uses the built in easing capabilities added In jQuery 1.1
+ * to offer multiple easing options
+ *
+ * TERMS OF USE - jQuery Easing
+ * 
+ * Open source under the BSD License. 
+ * 
+ * Copyright © 2008 George McGinley Smith
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification, 
+ * are permitted provided that the following conditions are met:
+ * 
+ * Redistributions of source code must retain the above copyright notice, this list of 
+ * conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice, this list 
+ * of conditions and the following disclaimer in the documentation and/or other materials 
+ * provided with the distribution.
+ * 
+ * Neither the name of the author nor the names of contributors may be used to endorse 
+ * or promote products derived from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY 
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ *  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ * OF THE POSSIBILITY OF SUCH DAMAGE. 
+ *
+*/
+
+// t: current time, b: begInnIng value, c: change In value, d: duration
+jQuery.easing['jswing'] = jQuery.easing['swing'];
+
+jQuery.extend( jQuery.easing,
+{
+	def: 'easeOutQuad',
+	swing: function (x, t, b, c, d) {
+		//alert(jQuery.easing.default);
+		return jQuery.easing[jQuery.easing.def](x, t, b, c, d);
+	},
+	easeInQuad: function (x, t, b, c, d) {
+		return c*(t/=d)*t + b;
+	},
+	easeOutQuad: function (x, t, b, c, d) {
+		return -c *(t/=d)*(t-2) + b;
+	},
+	easeInOutQuad: function (x, t, b, c, d) {
+		if ((t/=d/2) < 1) return c/2*t*t + b;
+		return -c/2 * ((--t)*(t-2) - 1) + b;
+	},
+	easeInCubic: function (x, t, b, c, d) {
+		return c*(t/=d)*t*t + b;
+	},
+	easeOutCubic: function (x, t, b, c, d) {
+		return c*((t=t/d-1)*t*t + 1) + b;
+	},
+	easeInOutCubic: function (x, t, b, c, d) {
+		if ((t/=d/2) < 1) return c/2*t*t*t + b;
+		return c/2*((t-=2)*t*t + 2) + b;
+	},
+	easeInQuart: function (x, t, b, c, d) {
+		return c*(t/=d)*t*t*t + b;
+	},
+	easeOutQuart: function (x, t, b, c, d) {
+		return -c * ((t=t/d-1)*t*t*t - 1) + b;
+	},
+	easeInOutQuart: function (x, t, b, c, d) {
+		if ((t/=d/2) < 1) return c/2*t*t*t*t + b;
+		return -c/2 * ((t-=2)*t*t*t - 2) + b;
+	},
+	easeInQuint: function (x, t, b, c, d) {
+		return c*(t/=d)*t*t*t*t + b;
+	},
+	easeOutQuint: function (x, t, b, c, d) {
+		return c*((t=t/d-1)*t*t*t*t + 1) + b;
+	},
+	easeInOutQuint: function (x, t, b, c, d) {
+		if ((t/=d/2) < 1) return c/2*t*t*t*t*t + b;
+		return c/2*((t-=2)*t*t*t*t + 2) + b;
+	},
+	easeInSine: function (x, t, b, c, d) {
+		return -c * Math.cos(t/d * (Math.PI/2)) + c + b;
+	},
+	easeOutSine: function (x, t, b, c, d) {
+		return c * Math.sin(t/d * (Math.PI/2)) + b;
+	},
+	easeInOutSine: function (x, t, b, c, d) {
+		return -c/2 * (Math.cos(Math.PI*t/d) - 1) + b;
+	},
+	easeInExpo: function (x, t, b, c, d) {
+		return (t==0) ? b : c * Math.pow(2, 10 * (t/d - 1)) + b;
+	},
+	easeOutExpo: function (x, t, b, c, d) {
+		return (t==d) ? b+c : c * (-Math.pow(2, -10 * t/d) + 1) + b;
+	},
+	easeInOutExpo: function (x, t, b, c, d) {
+		if (t==0) return b;
+		if (t==d) return b+c;
+		if ((t/=d/2) < 1) return c/2 * Math.pow(2, 10 * (t - 1)) + b;
+		return c/2 * (-Math.pow(2, -10 * --t) + 2) + b;
+	},
+	easeInCirc: function (x, t, b, c, d) {
+		return -c * (Math.sqrt(1 - (t/=d)*t) - 1) + b;
+	},
+	easeOutCirc: function (x, t, b, c, d) {
+		return c * Math.sqrt(1 - (t=t/d-1)*t) + b;
+	},
+	easeInOutCirc: function (x, t, b, c, d) {
+		if ((t/=d/2) < 1) return -c/2 * (Math.sqrt(1 - t*t) - 1) + b;
+		return c/2 * (Math.sqrt(1 - (t-=2)*t) + 1) + b;
+	},
+	easeInElastic: function (x, t, b, c, d) {
+		var s=1.70158;var p=0;var a=c;
+		if (t==0) return b;  if ((t/=d)==1) return b+c;  if (!p) p=d*.3;
+		if (a < Math.abs(c)) { a=c; var s=p/4; }
+		else var s = p/(2*Math.PI) * Math.asin (c/a);
+		return -(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
+	},
+	easeOutElastic: function (x, t, b, c, d) {
+		var s=1.70158;var p=0;var a=c;
+		if (t==0) return b;  if ((t/=d)==1) return b+c;  if (!p) p=d*.3;
+		if (a < Math.abs(c)) { a=c; var s=p/4; }
+		else var s = p/(2*Math.PI) * Math.asin (c/a);
+		return a*Math.pow(2,-10*t) * Math.sin( (t*d-s)*(2*Math.PI)/p ) + c + b;
+	},
+	easeInOutElastic: function (x, t, b, c, d) {
+		var s=1.70158;var p=0;var a=c;
+		if (t==0) return b;  if ((t/=d/2)==2) return b+c;  if (!p) p=d*(.3*1.5);
+		if (a < Math.abs(c)) { a=c; var s=p/4; }
+		else var s = p/(2*Math.PI) * Math.asin (c/a);
+		if (t < 1) return -.5*(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
+		return a*Math.pow(2,-10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )*.5 + c + b;
+	},
+	easeInBack: function (x, t, b, c, d, s) {
+		if (s == undefined) s = 1.70158;
+		return c*(t/=d)*t*((s+1)*t - s) + b;
+	},
+	easeOutBack: function (x, t, b, c, d, s) {
+		if (s == undefined) s = 1.70158;
+		return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b;
+	},
+	easeInOutBack: function (x, t, b, c, d, s) {
+		if (s == undefined) s = 1.70158; 
+		if ((t/=d/2) < 1) return c/2*(t*t*(((s*=(1.525))+1)*t - s)) + b;
+		return c/2*((t-=2)*t*(((s*=(1.525))+1)*t + s) + 2) + b;
+	},
+	easeInBounce: function (x, t, b, c, d) {
+		return c - jQuery.easing.easeOutBounce (x, d-t, 0, c, d) + b;
+	},
+	easeOutBounce: function (x, t, b, c, d) {
+		if ((t/=d) < (1/2.75)) {
+			return c*(7.5625*t*t) + b;
+		} else if (t < (2/2.75)) {
+			return c*(7.5625*(t-=(1.5/2.75))*t + .75) + b;
+		} else if (t < (2.5/2.75)) {
+			return c*(7.5625*(t-=(2.25/2.75))*t + .9375) + b;
+		} else {
+			return c*(7.5625*(t-=(2.625/2.75))*t + .984375) + b;
+		}
+	},
+	easeInOutBounce: function (x, t, b, c, d) {
+		if (t < d/2) return jQuery.easing.easeInBounce (x, t*2, 0, c, d) * .5 + b;
+		return jQuery.easing.easeOutBounce (x, t*2-d, 0, c, d) * .5 + c*.5 + b;
+	}
+});
+
+/*
+ *
+ * TERMS OF USE - EASING EQUATIONS
+ * 
+ * Open source under the BSD License. 
+ * 
+ * Copyright © 2001 Robert Penner
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification, 
+ * are permitted provided that the following conditions are met:
+ * 
+ * Redistributions of source code must retain the above copyright notice, this list of 
+ * conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice, this list 
+ * of conditions and the following disclaimer in the documentation and/or other materials 
+ * provided with the distribution.
+ * 
+ * Neither the name of the author nor the names of contributors may be used to endorse 
+ * or promote products derived from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY 
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ *  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ * OF THE POSSIBILITY OF SUCH DAMAGE. 
+ *
+ */

data/vendor/assets/javascripts/stackview/jquery.stackview.base.js

@@ -0,0 +1,561 @@
+/*!
+	Stack View - The jQuery virtual stack plugin
+	by The Harvard Library Innovation Lab
+	
+	Dual licensed under MIT and GPL.
+*/
+(function($, window, document, undefined) {
+	var events,
+	    plugin = 'stackView',
+	    StackView,
+	    types = {};
+	
+	events = {
+		init: 'stackview.init',
+		item_added: 'stackview.itemadded',
+		item_removed: 'stackview.itemremoved',
+		page_load: 'stackview.pageload'
+	};
+	
+	/*
+	   #get_type
+	*/
+	var get_type = function(item) {
+		var type;
+
+		$.each(types, function(key, val) {
+			if (val.match(item)) {
+				type = val;
+				return false;
+			}
+		});
+
+		return type;
+	};
+	
+	/*
+	   #render_items(StackView, array [, jQuery]) - Private
+	
+	   Takes a StackView instance, an array of result items, and an optional
+	   jQuery object.  Renders a DOM element for each of the items and
+	   appends it to the stack's item list. If [placeholder] is passed in the
+	   items take the its spot in the DOM.
+	*/
+	var render_items = function(stack, docs, $placeholder) {
+		var action = $placeholder ? 'before' : 'append',
+		    $pivot = $placeholder ?
+		             $placeholder :
+		             stack.$element.find(stack.options.selectors.item_list);
+		
+		$.each(docs, function(i, item) {
+			var type = get_type(item),
+			    $item;
+
+			if (type == null) {
+				return true;
+			}
+
+			$item = $(tmpl(type.template, type.adapter(item, stack.options)));
+			$item.data('stackviewItem', item);
+			$pivot[action]($item);
+		});
+
+		if ($placeholder) {
+			$placeholder.remove();
+		}
+		
+	};
+	
+	/*
+	   #calculate_params(StackView) - Private
+	
+	   Takes a StackView instance and returns the parameters for the next page.
+	   If the Stack uses loc_sort_order, this adjusts the query for that case.
+	   Returns a plain object with key:value params to be used by $.param.
+	*/
+	var calculate_params = function(stack) {
+		var opts = stack.options,
+		    params;
+		
+		params = {
+			start: stack.page * stack.options.items_per_page,
+			limit: stack.options.items_per_page,
+			search_type: stack.options.search_type,
+			query: stack.options.query
+		};
+		
+		if (params.search_type === 'loc_sort_order') {
+			params.start = 0;
+			
+			if (stack.page === 0) {
+				stack.loc = {
+					low: opts.id - Math.floor(opts.items_per_page / 2),
+					high: opts.id + Math.floor(opts.items_per_page / 2)
+				};
+				params.query = [
+					'[',
+					stack.loc.low,
+					' TO ',
+					stack.loc.high,
+					']'
+				].join('');
+			}
+			else if (stack.direction === 'down') {
+				params.query = [
+					'[',
+					stack.loc.high + 1,
+					' TO ',
+					stack.loc.high + opts.items_per_page + 1,
+					']'
+				].join('');
+				stack.loc.high = stack.loc.high + opts.items_per_page + 1;
+			}
+			else if (stack.direction === 'up') {
+				params.query = [
+					'[',
+					stack.loc.low - opts.items_per_page - 1,
+					' TO ',
+					stack.loc.low - 1,
+					']'
+				].join('');
+				stack.loc.low = stack.loc.low - opts.items_per_page - 1;
+			}
+		}
+		
+		return params;
+	};
+
+	/*
+	   #fetch_page(StackView, function) - Private
+	
+	   Takes a StackView instance and a callback function.  Retrieves the
+	   next page according to the URL and other options of the StackView
+	   instance.  When the page is finished fetching, the callback is
+	   invoked, passing in the array of items.
+	*/
+	var fetch_page = function(stack, callback) {
+		var params = calculate_params(stack),
+				querystring = $.param(params),
+				cachedResult;
+
+		stack.page++;
+		cachedResult = window.stackCache.get(stack.options.url + querystring);
+		
+		if (cachedResult) {
+			callback(cachedResult);
+		}
+		else {
+			$.ajax({
+				url: stack.options.url,
+				data: querystring,
+				dataType: stack.options.jsonp ? 'jsonp' : 'json',
+				success: function(data) {
+					window.stackCache.set(
+						stack.options.url + params,
+						data,
+						stack.options.cache_ttl
+					);	
+					callback(data);
+				}
+			});
+		}
+	};
+
+
+
+	
+	/* StackView constructor, set up instance properties and call init. */
+	StackView = function(elem, opts) {
+		this.element = elem;
+		this.$element = $(elem);
+		this.options = $.extend(true, {}, StackView.defaults, opts);
+		this.page = 0;
+		this.finished = {
+			up: false,
+			down: false
+		};
+		this.loc = {
+			low: null,
+			high: null
+		};
+		this.direction = 'down';
+		this.init();
+	};
+	
+	/* Static properties and functions */
+	$.extend(true, StackView, {
+
+			/*
+		   The default options for a StackView instance.
+		
+		   cache_ttl
+		      How long a request will stay in cache.
+
+		   data
+		      An alternative to URL, used for static data. Accepts a typical
+		      URL response object or a simple array of item objects.
+
+		   id
+		      When using a search type of loc_sort_order, this is the id of
+		      the item that the search centers around.
+
+		   items_per_page
+		      The number of items to request each page.
+
+		   jsonp
+		      If true, the URL will expect a JSONP request. callback=? will be
+		      added to the request parameters.
+
+		   query
+		      The query passed to the script at URL.  Passed as the
+		      query parameter.
+
+		   ribbon
+		      The text of the ribbon at the top of the stack.
+
+		   search_type
+		      The type of search to be performed by the script at URL. This is
+		      passed to the script as the search_type parameter.
+
+		   selectors
+		      A number of selectors that are frequently used by the code to
+		      identify key structures.
+
+		      item
+		         A single item in the stack.
+
+		      item_list
+		         Container around all of the stack items.
+
+		      ribbon
+		         The text ribbon at the top of the stack.
+
+		   url
+		      The URL to send requests to for item data.
+		*/
+		defaults: {
+			cache_ttl: 60,
+			data: '',
+			id: null,
+			items_per_page: 10,
+			jsonp: false,
+			query: '',
+			ribbon: 'Stack View',
+			search_type: 'keyword',
+			selectors: {
+				item: '.stack-item',
+				item_list: '.stack-items',
+				ribbon: '.ribbon'
+			},
+			url: 'basic.json'
+		},
+
+		/*
+	     StackView.get_heat(number)
+	
+	      Takes a value between 0 and 100 and returns a number to be used with
+	      heat classes to indicate popularity.
+		*/
+		utils: {
+			get_heat: function(scaled_value) {
+				return scaled_value === 100 ? 10 : Math.floor(scaled_value / 10) + 1;
+			}
+		},
+
+		/*
+		   StackView.register_type(object)
+
+		   Registers an item type to be used by the stack. A Type object
+		   has the following properties:
+
+		   name: string
+		     A unique, identifying name of the item type.
+
+		   match: function(obj) -> obj
+		     A function that takes a stack item and returns true if the
+		     item matches this type. Example:
+
+		       match: function(item) { return item.type === 'book' }
+
+		   adapter: function(obj, obj) -> obj
+		     This function allows the user to make transformations to the
+		     item data before rendering it to the template.  It takes as
+		     parameters a raw item that matches the match function and the
+		     options from the StackView instance.  It should return an object
+		     to render against "template."  If no changes to the raw data need
+		     to be made, the simplest value for this can be:
+
+		       adapter: function(item) { return item; }
+
+		   template: string
+		     A microtemplating template to render for this type in the stack.
+		     Receives as its data the return value from "adapter."
+
+		*/
+		register_type: function(obj) {
+			types[obj.name] = obj;
+		},
+
+		/*
+		   StackView.get_types()
+
+		   Returns the hash of item types.
+		*/
+		get_types: function() {
+			return types;
+		}
+	});
+	
+	/*
+	   StackView public methods
+	*/
+	$.extend(true, StackView.prototype, {
+		
+		/*
+		   #init()
+		
+		   Sets up the initial states of a stack.  Including:
+		     - Creating the HTML skeleton.
+		     - Binding zIndex ordering to the pageload event.
+		     - Loading the first page.
+		     - Firing the init event.
+		*/
+		init: function() {
+			var that = this;
+			
+			this.$element
+				.html(tmpl(StackView.templates.scaffold, {
+					ribbon: this.options.ribbon
+				}))
+				.addClass('stackview')
+				.bind(events.page_load, function() {
+					that.zIndex();
+				});
+			
+			this.$element.data('stackviewObject', this);
+			this.$element.trigger(events.init);
+			this.next_page();
+		},
+		
+		/*
+		   #next_page()
+		
+		   Loads the next page of stack items.  If we've already hit the
+		   last page, this function does nothing.
+		*/
+		next_page: function() {
+			var $placeholder = $(tmpl(StackView.templates.placeholder, {})),
+			    that = this,
+			    opts = this.options;
+			
+			if (this.finished.down) {
+				return;
+			}
+			
+			this.direction = 'down';
+			if (opts.data) {
+				render_items(this, opts.data.docs ? opts.data.docs : opts.data);
+				this.finished.down = true;
+				this.$element.trigger(events.page_load, [opts.data]);
+			}
+			else if (opts.url) {
+				this.$element
+					.find(opts.selectors.item_list)
+					.append($placeholder);
+				fetch_page(this, function(data) {
+					render_items(that, data.docs, $placeholder);
+					if (parseInt(data.start, 10) === -1) {
+						that.finished.down = true;
+					}
+					that.$element.trigger(events.page_load, [data]);
+				});
+			}
+		},
+		
+		/*
+		   #prev_page()
+		
+		   Loads the previous page of stack items.  If we've already hit the
+		   first page this function does nothing.  This function only works
+		   for stacks using the loc_sort_order search type.
+		*/
+		prev_page: function() {
+			var $placeholder = $(tmpl(StackView.templates.placeholder, {})),
+			    opts = this.options,
+			    that = this,
+			    $oldMarker = that.$element.find(opts.selectors.item).first();
+			
+			if (opts.search_type !== 'loc_sort_order' || this.finished.up) {
+				return;
+			}
+			
+			this.direction = 'up';
+			this.$element.find(opts.selectors.item_list).prepend($placeholder);
+			fetch_page(this, function(data) {
+				var oldTop = $oldMarker.position().top;
+				
+				render_items(that, data.docs, $placeholder);
+				if (that.page > 1) {
+					that.$element.find(opts.selectors.item_list).animate({
+						'scrollTop': '+=' + ($oldMarker.position().top - oldTop)
+					}, 0);
+				}
+				if (parseInt(data.start, 10) === -1) {
+					that.finished.up = true;
+				}
+				that.$element.trigger(events.page_load, [data]);
+			});
+		},
+		
+		/*
+		   #add([number,] object)
+		
+		   Adds the specified item object to the stack, at the given index if
+		   provided or at the end (bottom) of the stack if index is not given.
+		*/
+		add: function() {
+			var $items = this.$element.find(this.options.selectors.item),
+			    index, item, type, action, $pivot, $item;
+			
+			if (typeof(arguments[0]) === 'number') {
+				index = arguments[0];
+				item = arguments[1];
+			}
+			else {
+				index = $items.length;
+				item = arguments[0];
+			}
+
+			if (index > $items.length || index < 0) {
+				return;
+			}
+			else if (index === $items.length) {
+				$pivot = $items.last();
+				action = 'after';
+			}
+			else {
+				$pivot = $items.eq(index);
+				action = 'before';
+			}
+			
+			type = get_type(item);
+			if (type == null) {
+				return;
+			}
+			$item = $(tmpl(type.template, type.adapter(item, this.options)));
+
+			$item.data('stackviewItem', item);
+			$pivot[action]($item);
+			this.zIndex();
+			this.$element.trigger(events.item_added);
+		},
+		
+		/*
+		   #remove(number | object)
+		
+		   If a number is given, it removes the item at that index. If an
+		   object is given, this method finds the element that represents that
+		   item and removes it.
+		*/
+		remove: function(arg) {
+			var $items = this.$element.find(this.options.selectors.item),
+			    $found, data, index;
+			
+			if (typeof(arg) === 'number') {
+				$found = $items.eq(arg);
+			}
+			else if (arg.nodeType || arg.jquery){
+				$found = $(arg);
+			}
+			else {
+				$items.each(function(i, el) {
+					var $el = $(el);
+					
+					if ($el.data('stackviewItem') === arg) {
+						$found = $el;
+						return false;
+					}
+				});
+			}
+			
+			if ($found == null || !$found.length) {
+				return;
+			}
+			
+			$found.detach();
+			data = $found.data('stackviewItem');
+			this.$element.trigger(events.item_removed, [data]);
+			return $found;
+		},
+		
+		
+		/*
+		   #getData()
+		
+		   Returns an array of all the item objects currently in the stack.
+		*/
+		getData: function() {
+			var data = [];
+			
+			this.$element.find(this.options.selectors.item).each(function() {
+				data.push($(this).data('stackviewItem'));
+			});
+			
+			return data;
+		},
+		
+		/*
+		   #zIndex(boolean)
+		
+		   Reverses the natural flow order of the stack items by giving those
+		   earlier in the source (higher on the stack) a higher z-index.  If
+		   passed true, it will instead assign z-indexes in normal flow order.
+		*/
+		zIndex: function(reverse) {
+			var $items = this.$element.find(this.options.selectors.item),
+			    length = $items.length,
+			    i = 0,
+			    z = reverse ? 0 : $items.length - 1;
+			
+			while (i < length) {
+				$items.eq(i).css('z-index', z);
+				z = z + (reverse ? 1 : -1);
+				i++;
+			}
+		}
+	});
+	
+	/*
+	   If .stackView has not been called on an element, the first call will
+	   initialize the plugin. Subsequent calls expect a method from the
+	   StackView class. Any method that returns undefined is assumed to
+	   chain. If the method returns a value, only the value from the first
+	   element in the jQuery set will be returned, the same as other getters
+	   in jQuery.
+	*/
+	$.fn[plugin] = function(method) {
+		var response,
+		    args = Array.prototype.slice.call(arguments, 1);
+		
+		this.each(function(i, el) {
+			var $el = $(el),
+			    obj = $el.data('stackviewObject');
+			
+			if (!obj) {
+				new StackView(el, method);
+			}
+			else if (obj[method]) {
+				var methodResponse = obj[method].apply(obj, args);
+				
+				if (response === undefined && methodResponse !== undefined) {
+					response = methodResponse;
+				}
+			}
+		});
+		
+		return response === undefined ? this : response;
+	};
+	
+	/* Expose the StackView class for extension */
+	window.StackView = StackView;
+})(jQuery, window, document);